diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 380c8d4a4b..68350af8de 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -34,6 +34,7 @@ set(
       collective/scatter/
       collective/reduce/
         collective/reduce/operators collective/reduce/functors
+        collective/reduce/allreduce
     elm
     group/id group/region group/global group/msg group/collective group/rooted
     group/base
@@ -98,7 +99,7 @@ set(
       serialization/messaging serialization/traits serialization/auto_dispatch
       serialization/sizing
     utils/demangle utils/container utils/bits utils/mutex utils/file_spec
-    utils/hash utils/atomic utils/static_checks utils/string
+    utils/hash utils/atomic utils/static_checks utils/string utils/kokkos
     utils/memory utils/mpi_limits utils/compress utils/json utils/strong
     registry/auto
       registry/auto/functor registry/auto/map registry/auto/collection
diff --git a/src/vt/collective/reduce/allreduce/allreduce_holder.cc b/src/vt/collective/reduce/allreduce/allreduce_holder.cc
new file mode 100644
index 0000000000..a79f90ba34
--- /dev/null
+++ b/src/vt/collective/reduce/allreduce/allreduce_holder.cc
@@ -0,0 +1,191 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                             allreduce_holder.cc
+//                       DARMA/vt => Virtual Transport
+//
+// Copyright 2019-2024 National Technology & Engineering Solutions of Sandia, LLC
+// (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact darma@sandia.gov
+//
+// *****************************************************************************
+//@HEADER
+*/
+#include "allreduce_holder.h"
+#include "vt/objgroup/manager.h"
+#include "state_holder.h"
+
+namespace vt::collective::reduce::allreduce {
+
+template <typename MapT>
+inline static void removeImpl(MapT& map, uint64_t key){
+  auto it = map.find(key);
+
+  if (it != map.end()) {
+    auto& [rabenseifner, recursive_doubling] = map.at(key);
+
+    if(rabenseifner) {
+      delete rabenseifner;
+    }
+
+    if(recursive_doubling) {
+      delete recursive_doubling;
+    }
+
+    map.erase(key);
+  }
+}
+
+Rabenseifner* AllreduceHolder::addRabensifnerAllreducer(
+  detail::StrongVrtProxy strong_proxy, detail::StrongGroup strong_group,
+  size_t num_elems) {
+  auto const coll_proxy = strong_proxy.get();
+
+  auto obj_proxy = new Rabenseifner(strong_proxy, strong_group, num_elems);
+
+  col_reducers_[coll_proxy].first = obj_proxy;
+
+  vt_debug_print(
+    verbose, allreduce, "Adding new Rabenseifner reducer for collection={:x}\n",
+    coll_proxy
+  );
+
+  return obj_proxy;
+}
+
+RecursiveDoubling*
+AllreduceHolder::addRecursiveDoublingAllreducer(
+  detail::StrongVrtProxy strong_proxy, detail::StrongGroup strong_group,
+  size_t num_elems) {
+  auto const coll_proxy = strong_proxy.get();
+  auto obj_proxy = new RecursiveDoubling(
+    strong_proxy, strong_group, num_elems);
+
+  col_reducers_[coll_proxy].second = obj_proxy;
+
+  vt_debug_print(
+    verbose, allreduce,
+    "Adding new RecursiveDoubling reducer for collection={:x}\n", coll_proxy
+  );
+
+  return obj_proxy;
+}
+
+Rabenseifner*
+AllreduceHolder::addRabensifnerAllreducer(detail::StrongGroup strong_group) {
+  auto const group = strong_group.get();
+
+  auto obj_proxy = new Rabenseifner(
+    strong_group);
+
+  group_reducers_[group].first = obj_proxy;
+
+  vt_debug_print(
+    verbose, allreduce,
+    "Adding new Rabenseifner reducer for group={:x}\n", group
+  );
+
+  return obj_proxy;
+}
+
+RecursiveDoubling*
+AllreduceHolder::addRecursiveDoublingAllreducer(
+  detail::StrongGroup strong_group) {
+  auto const group = strong_group.get();
+
+  auto obj_proxy = new RecursiveDoubling(
+    strong_group);
+
+  vt_debug_print(
+    verbose, allreduce,
+    "Adding new RecursiveDoubling reducer for group={:x}\n", group
+  );
+
+  group_reducers_[group].second = obj_proxy;
+
+  return obj_proxy;
+}
+
+Rabenseifner*
+AllreduceHolder::addRabensifnerAllreducer(detail::StrongObjGroup strong_objgroup) {
+  auto const objgroup = strong_objgroup.get();
+
+  auto obj_proxy = new Rabenseifner(
+    strong_objgroup);
+
+  objgroup_reducers_[objgroup].first = obj_proxy;
+
+  vt_debug_print(
+    verbose, allreduce,
+    "Adding new Rabenseifner reducer for objgroup={:x}\n", objgroup
+  );
+
+  return obj_proxy;
+}
+
+RecursiveDoubling*
+AllreduceHolder::addRecursiveDoublingAllreducer(
+  detail::StrongObjGroup strong_objgroup) {
+  auto const objgroup = strong_objgroup.get();
+
+  auto obj_proxy = new RecursiveDoubling(
+    strong_objgroup);
+
+  vt_debug_print(
+    verbose, allreduce,
+    "Adding new RecursiveDoubling reducer for objgroup={:x}\n", objgroup
+  );
+
+  objgroup_reducers_[objgroup].second = obj_proxy;
+
+  return obj_proxy;
+}
+
+void AllreduceHolder::remove(detail::StrongVrtProxy strong_proxy) {
+  auto const key = strong_proxy.get();
+  StateHolder::clearAll(strong_proxy);
+  removeImpl(col_reducers_, key);
+}
+
+void AllreduceHolder::remove(detail::StrongGroup strong_group) {
+  auto const key = strong_group.get();
+  StateHolder::clearAll(strong_group);
+  removeImpl(group_reducers_, key);
+}
+
+void AllreduceHolder::remove(detail::StrongObjGroup strong_objgroup) {
+  auto const key = strong_objgroup.get();
+  StateHolder::clearAll(strong_objgroup);
+  removeImpl(objgroup_reducers_, key);
+}
+
+} // namespace vt::collective::reduce::allreduce
diff --git a/src/vt/collective/reduce/allreduce/allreduce_holder.h b/src/vt/collective/reduce/allreduce/allreduce_holder.h
new file mode 100644
index 0000000000..8b9a083227
--- /dev/null
+++ b/src/vt/collective/reduce/allreduce/allreduce_holder.h
@@ -0,0 +1,142 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                              allreduce_holder.h
+//                       DARMA/vt => Virtual Transport
+//
+// Copyright 2019-2024 National Technology & Engineering Solutions of Sandia, LLC
+// (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact darma@sandia.gov
+//
+// *****************************************************************************
+//@HEADER
+*/
+
+#if !defined INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_ALLREDUCE_HOLDER_H
+#define INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_ALLREDUCE_HOLDER_H
+
+#include "vt/configs/types/types_type.h"
+#include "vt/collective/reduce/allreduce/type.h"
+#include "vt/collective/reduce/scoping/strong_types.h"
+#include "vt/objgroup/proxy/proxy_objgroup.h"
+
+#include <unordered_map>
+
+namespace vt::collective::reduce::allreduce {
+
+struct Rabenseifner;
+struct RecursiveDoubling;
+
+struct AllreduceHolder {
+  using RabenseifnerProxy = ObjGroupProxyType;
+  using RecursiveDoublingProxy = ObjGroupProxyType;
+
+  template <typename ReducerT>
+  static decltype(auto) getAllreducer(detail::StrongVrtProxy strong_proxy);
+
+  template <typename ReducerT>
+  static decltype(auto) getAllreducer(detail::StrongGroup strong_group);
+
+  template <typename ReducerT>
+  static decltype(auto) getAllreducer(detail::StrongObjGroup strong_objgroup);
+
+  template <typename ReducerT>
+  static decltype(auto) getOrCreateAllreducer(
+    detail::StrongVrtProxy strong_proxy, detail::StrongGroup strong_group,
+    size_t num_elems);
+
+  template <typename ReducerT>
+  static decltype(auto) getOrCreateAllreducer(detail::StrongGroup strong_group);
+
+  template <typename ReducerT>
+  static decltype(auto)
+  getOrCreateAllreducer(detail::StrongObjGroup strong_objgroup);
+
+  static void remove(detail::StrongVrtProxy strong_proxy);
+  static void remove(detail::StrongGroup strong_group);
+  static void remove(detail::StrongObjGroup strong_group);
+
+private:
+  template <typename ReducerT, typename MapT>
+  static decltype(auto) getAllreducerImpl(MapT& map, uint64_t id);
+
+  template <typename ReducerT, typename MapT, typename... Args>
+  static decltype(auto) getOrCreateAllreducerImpl(MapT& map, uint64_t id, Args&&... args);
+
+  static Rabenseifner* addRabensifnerAllreducer(
+    detail::StrongVrtProxy strong_proxy, detail::StrongGroup strong_group,
+    size_t num_elems);
+
+  static RecursiveDoubling* addRecursiveDoublingAllreducer(
+    detail::StrongVrtProxy strong_proxy, detail::StrongGroup strong_group,
+    size_t num_elems);
+
+  static Rabenseifner*
+  addRabensifnerAllreducer(detail::StrongGroup strong_group);
+  static RecursiveDoubling*
+  addRecursiveDoublingAllreducer(detail::StrongGroup strong_group);
+
+  static Rabenseifner*
+  addRabensifnerAllreducer(detail::StrongObjGroup strong_group);
+  static RecursiveDoubling*
+  addRecursiveDoublingAllreducer(detail::StrongObjGroup strong_group);
+
+  static inline std::unordered_map<
+    VirtualProxyType, std::pair<Rabenseifner*, RecursiveDoubling*>>
+    col_reducers_ = {};
+  static inline std::unordered_map<
+    GroupType, std::pair<Rabenseifner*, RecursiveDoubling*>>
+    group_reducers_ = {};
+  static inline std::unordered_map<
+    ObjGroupProxyType, std::pair<Rabenseifner*, RecursiveDoubling*>>
+    objgroup_reducers_ = {};
+};
+
+template <typename ReducerT>
+static inline auto* getAllreducer(ComponentInfo type) {
+  if (type.first == ComponentT::VrtColl) {
+    return AllreduceHolder::getAllreducer<ReducerT>(
+      detail::StrongVrtProxy{type.second});
+  } else if (type.first == ComponentT::ObjGroup) {
+    return AllreduceHolder::getAllreducer<ReducerT>(
+      detail::StrongObjGroup{type.second});
+  } else {
+    return AllreduceHolder::getAllreducer<ReducerT>(
+      detail::StrongGroup{type.second});
+  }
+}
+
+} // namespace vt::collective::reduce::allreduce
+
+#include "vt/collective/reduce/allreduce/allreduce_holder.impl.h"
+
+#endif /*INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_ALLREDUCE_HOLDER_H*/
diff --git a/src/vt/collective/reduce/allreduce/allreduce_holder.impl.h b/src/vt/collective/reduce/allreduce/allreduce_holder.impl.h
new file mode 100644
index 0000000000..e9845c8307
--- /dev/null
+++ b/src/vt/collective/reduce/allreduce/allreduce_holder.impl.h
@@ -0,0 +1,142 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                           allreduce_holder.impl.h
+//                       DARMA/vt => Virtual Transport
+//
+// Copyright 2019-2024 National Technology & Engineering Solutions of Sandia, LLC
+// (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact darma@sandia.gov
+//
+// *****************************************************************************
+//@HEADER
+*/
+
+#if !defined INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_ALLREDUCE_HOLDER_IMPL_H
+#define INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_ALLREDUCE_HOLDER_IMPL_H
+
+#include "vt/collective/reduce/allreduce/allreduce_holder.h"
+
+#include <type_traits>
+
+namespace vt::collective::reduce::allreduce {
+
+template <typename ReducerT, typename MapT>
+decltype(auto) AllreduceHolder::getAllreducerImpl(MapT& map, uint64_t id) {
+  auto it = map.find(id);
+  if (it == map.end()) {
+    map[id] = {nullptr, nullptr};
+  }
+
+  if constexpr (std::is_same_v<ReducerT, RabenseifnerT>) {
+    return map.at(id).first;
+  } else {
+    return map.at(id).second;
+  }
+}
+
+template <typename ReducerT>
+decltype(auto)
+AllreduceHolder::getAllreducer(detail::StrongVrtProxy strong_proxy) {
+  auto const coll_proxy = strong_proxy.get();
+
+  return getAllreducerImpl<ReducerT>(col_reducers_, coll_proxy);
+}
+
+template <typename ReducerT>
+decltype(auto) AllreduceHolder::getAllreducer(detail::StrongGroup strong_group) {
+  auto const group = strong_group.get();
+
+  return getAllreducerImpl<ReducerT>(group_reducers_, group);
+}
+
+template <typename ReducerT>
+decltype(auto)
+AllreduceHolder::getAllreducer(detail::StrongObjGroup strong_objgroup) {
+  auto const objgroup = strong_objgroup.get();
+
+  return getAllreducerImpl<ReducerT>(objgroup_reducers_, objgroup);
+}
+
+template <typename ReducerT, typename MapT, typename... Args>
+decltype(auto) AllreduceHolder::getOrCreateAllreducerImpl(
+  MapT& map, uint64_t id, Args&&... args) {
+  if (map.find(id) == col_reducers_.end()) {
+    map[id] = {nullptr, nullptr};
+  }
+
+  if constexpr (std::is_same_v<ReducerT, RabenseifnerT>) {
+    auto reducer = map.at(id).first;
+    if (reducer == nullptr) {
+      return addRabensifnerAllreducer(std::forward<Args>(args)...);
+    } else {
+      return reducer;
+    }
+  } else {
+    auto reducer = map.at(id).second;
+    if (reducer == nullptr) {
+      return addRecursiveDoublingAllreducer(std::forward<Args>(args)...);
+    } else {
+      return reducer;
+    }
+  }
+}
+
+template <typename ReducerT>
+decltype(auto) AllreduceHolder::getOrCreateAllreducer(
+  detail::StrongVrtProxy strong_proxy, detail::StrongGroup strong_group,
+  size_t num_elems) {
+  auto const coll_proxy = strong_proxy.get();
+
+  return getOrCreateAllreducerImpl<ReducerT>(
+    col_reducers_, coll_proxy, strong_proxy, strong_group, num_elems);
+}
+
+template <typename ReducerT>
+decltype(auto)
+AllreduceHolder::getOrCreateAllreducer(detail::StrongGroup strong_group) {
+  auto const group = strong_group.get();
+  return getOrCreateAllreducerImpl<ReducerT>(
+    col_reducers_, group, strong_group);
+}
+
+template <typename ReducerT>
+decltype(auto)
+AllreduceHolder::getOrCreateAllreducer(detail::StrongObjGroup strong_objgroup) {
+  auto const objgroup = strong_objgroup.get();
+  return getOrCreateAllreducerImpl<ReducerT>(
+    objgroup_reducers_, objgroup, strong_objgroup);
+}
+
+} // namespace vt::collective::reduce::allreduce
+
+#endif /*INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_ALLREDUCE_HOLDER_IMPL_H*/
diff --git a/src/vt/collective/reduce/allreduce/data_handler.h b/src/vt/collective/reduce/allreduce/data_handler.h
new file mode 100644
index 0000000000..d6ede93221
--- /dev/null
+++ b/src/vt/collective/reduce/allreduce/data_handler.h
@@ -0,0 +1,140 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                                data_handler.h
+//                       DARMA/vt => Virtual Transport
+//
+// Copyright 2019-2024 National Technology & Engineering Solutions of Sandia, LLC
+// (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact darma@sandia.gov
+//
+// *****************************************************************************
+//@HEADER
+*/
+
+#if !defined INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_DATA_HANDLER_H
+#define INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_DATA_HANDLER_H
+
+#include "vt/configs/error/config_assert.h"
+
+#include <vector>
+
+#ifdef MAGISTRATE_KOKKOS_ENABLED
+#include <Kokkos_Core.hpp>
+#endif // MAGISTRATE_KOKKOS_ENABLED
+
+namespace vt::collective::reduce::allreduce {
+
+template <typename DataType, typename Enable = void>
+class DataHandler {
+public:
+  using Scalar = void;
+
+  static DataType toVec(const DataType&) {
+    vtAssert(
+      true,
+      "Using default DataHandler! This means that you're using custom type for "
+      "allreduce. Please provide specialization for you data type."
+    );
+
+    return {};
+  }
+  static DataType fromVec(const std::vector<Scalar>&) {
+    vtAssert(
+      true,
+      "Using default DataHandler! This means that you're using custom type for "
+      "allreduce. Please provide specialization for you data type."
+    );
+
+    return {};
+  }
+
+  static size_t size(void) {
+    vtAssert(
+      true,
+      "Using default DataHandler! This means that you're using custom type for "
+      "allreduce. Please provide specialization for you data type."
+    );
+
+    return {};
+  }
+};
+
+template <typename ScalarType>
+class DataHandler<ScalarType, typename std::enable_if<std::is_arithmetic<ScalarType>::value>::type> {
+public:
+  using Scalar = ScalarType;
+
+  static std::vector<ScalarType> toVec(const ScalarType& data) { return std::vector<ScalarType>{data}; }
+  static ScalarType fromVec(const std::vector<ScalarType>& data) { return data[0]; }
+
+  static size_t size(const ScalarType&) { return 1; }
+};
+
+template <typename T>
+class DataHandler<std::vector<T>> {
+public:
+  using Scalar = T;
+
+  static const std::vector<T>& toVec(const std::vector<T>& data) { return data; }
+  static std::vector<T> fromVec(const std::vector<T>& data) { return data; }
+  static size_t size(const std::vector<T>& data) { return data.size(); }
+};
+
+#if MAGISTRATE_KOKKOS_ENABLED
+
+template <typename T, typename... Props>
+class DataHandler<Kokkos::View<T*, Kokkos::HostSpace, Props...>> {
+  using ViewType = Kokkos::View<T*, Kokkos::HostSpace, Props...>;
+
+public:
+  using Scalar = T;
+
+  static std::vector<T> toVec(const ViewType& data) {
+    return std::vector<T>(data.data(), data.data() + data.extent(0));
+  }
+
+  static ViewType fromVec(const std::vector<T>& data) {
+    ViewType view("view", data.size());
+    auto data_view = Kokkos::View<const T*, Kokkos::HostSpace, Kokkos::MemoryUnmanaged>(data.data(), data.size());
+    Kokkos::deep_copy(view, data_view);
+    return view;
+  }
+
+  static size_t size(const ViewType& data) { return data.extent(0); }
+};
+
+#endif // MAGISTRATE_KOKKOS_ENABLED
+
+} // namespace vt::collective::reduce::allreduce
+
+#endif /*INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_DATA_HANDLER_H*/
diff --git a/src/vt/collective/reduce/allreduce/helpers.h b/src/vt/collective/reduce/allreduce/helpers.h
new file mode 100644
index 0000000000..d220b24836
--- /dev/null
+++ b/src/vt/collective/reduce/allreduce/helpers.h
@@ -0,0 +1,195 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                                  helpers.h
+//                       DARMA/vt => Virtual Transport
+//
+// Copyright 2019-2024 National Technology & Engineering Solutions of Sandia, LLC
+// (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact darma@sandia.gov
+//
+// *****************************************************************************
+//@HEADER
+*/
+
+#if !defined INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_HELPERS_H
+#define INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_HELPERS_H
+
+#include "data_handler.h"
+#include "rabenseifner_msg.h"
+#include "vt/messaging/message/shared_message.h"
+#include "vt/utils/kokkos/exec_space.h"
+#include "vt/utils/kokkos/reduce_op.h"
+
+#include <vector>
+
+namespace vt::collective::reduce::allreduce {
+
+template <typename Scalar, typename DataT>
+struct ShouldUseView {
+  static constexpr bool Value = false;
+};
+
+#if MAGISTRATE_KOKKOS_ENABLED
+template <typename Scalar, typename... Properties>
+struct ShouldUseView<Scalar, Kokkos::View<Scalar*, Properties...>> {
+  static constexpr bool Value = true;
+};
+
+#endif // MAGISTRATE_KOKKOS_ENABLED
+
+template <typename Scalar, typename DataT>
+inline constexpr bool ShouldUseView_v = ShouldUseView<Scalar, DataT>::Value;
+
+template <typename Scalar, typename DataT>
+struct DataHelper {
+  using DataHan = DataHandler<DataT>;
+
+  template <typename... Args>
+  static void assignFromMem(std::vector<Scalar>& dest, const Scalar* data, size_t size) {
+    vtAssert(
+      dest.size() == size,
+      fmt::format(
+        "DataHelper::assignFromMem vector(size={}) and memory(size={}) differ!",
+        dest.size(), size
+      )
+    );
+
+    std::memcpy(dest.data(), data, size * sizeof(Scalar));
+  }
+
+  template <typename... Args>
+  static void assign(std::vector<Scalar>& dest, Args&&... data) {
+    dest = DataHan::toVec(std::forward<Args>(data)...);
+  }
+
+  static auto createMessage(
+    ComponentInfo info,
+    const std::vector<Scalar>& payload, size_t begin, size_t count, size_t id,
+    int32_t step = 0) {
+    return vt::makeMessage<RabenseifnerMsg<Scalar, DataT>>(
+      info, payload.data() + begin, count, id, step);
+  }
+
+  static void copy(
+    std::vector<Scalar>& dest, size_t start_idx, RabenseifnerMsg<Scalar, DataT>* msg) {
+    for (uint32_t i = 0; i < msg->size_; i++) {
+      dest[start_idx + i] = msg->val_[i];
+    }
+  }
+
+  template <template <typename Arg> class Op>
+  static void reduceMsg(
+    std::vector<Scalar>& dest, size_t start_idx, RabenseifnerMsg<Scalar, DataT>* msg) {
+    for (uint32_t i = 0; i < msg->size_; i++) {
+      Op<Scalar>()(dest[start_idx + i], msg->val_[i]);
+    }
+  }
+
+  template <template <typename Arg> class Op, typename... Args>
+  static void reduce(
+    std::vector<Scalar>& dest, Args &&... data) {
+    auto& vector_val = DataHan::toVec(std::forward<Args>(data)...);
+    Op<std::vector<Scalar>>()(dest, vector_val);
+  }
+
+  static bool empty(const std::vector<Scalar>& payload) {
+    return payload.empty();
+  }
+};
+
+#if MAGISTRATE_KOKKOS_ENABLED
+
+template <typename Scalar, typename... Properties>
+struct DataHelper<Scalar, Kokkos::View<Scalar*, Properties...>> {
+  using DataT = Kokkos::View<Scalar*, Properties...>;
+  using ExecSpace = typename utils::kokkos::AssociatedExecSpace<Properties...>::type;
+  using DataType = DataHandler<DataT>;
+
+  template <typename... Args>
+  static void assign(DataT& dest, Args&&... data) {
+    dest = {std::forward<Args>(data)...};
+  }
+
+  static auto createMessage(
+    ComponentInfo info, const DataT& payload, size_t begin, size_t count, size_t id,
+    int32_t step = 0) {
+    return vt::makeMessage<RabenseifnerMsg<Scalar, DataT>>(info,
+      Kokkos::subview(payload, std::make_pair(begin, begin + count)), id, step
+    );
+  }
+
+  static void
+  copy(DataT& dest, size_t start_idx, RabenseifnerMsg<Scalar, DataT>* msg) {
+
+    Kokkos::RangePolicy<ExecSpace> policy(0, msg->val_.extent(0));
+    Kokkos::parallel_for(
+      "Rabenseifner::copy", policy,
+      KOKKOS_LAMBDA(const int i) { dest(start_idx + i) = msg->val_(i); }
+    );
+  }
+
+  template <template <typename Arg> class Op>
+  static void reduceMsg(
+    DataT& dest, size_t start_idx, RabenseifnerMsg<Scalar, DataT>* msg) {
+
+    Kokkos::RangePolicy<ExecSpace> policy(0, msg->val_.extent(0));
+    Kokkos::parallel_for(
+      "Rabenseifner::reduceMsg", policy, KOKKOS_LAMBDA(const int i) {
+        utils::kokkos::KokkosOp<Op<Scalar>>()(dest(start_idx + i), msg->val_(i));
+      }
+    );
+  }
+
+  template <template <typename Arg> class Op, typename... Args>
+  static void reduce(
+    DataT& dest, Args&&... val) {
+    auto view_val = DataT{std::forward<Args>(val)...};
+
+    Kokkos::RangePolicy<ExecSpace> policy(0, view_val.extent(0));
+    Kokkos::parallel_for(
+      "Rabenseifner::reduce", policy, KOKKOS_LAMBDA(const int i) {
+        utils::kokkos::KokkosOp<Op<Scalar>>()(dest(i), view_val(i));
+      }
+    );
+  }
+
+  static bool empty(const DataT& payload) {
+    return payload.extent(0) == 0;
+  }
+};
+
+#endif // MAGISTRATE_KOKKOS_ENABLED
+
+} // namespace vt::collective::reduce::allreduce
+
+#endif /*INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_HELPERS_H*/
diff --git a/src/vt/collective/reduce/allreduce/rabenseifner.cc b/src/vt/collective/reduce/allreduce/rabenseifner.cc
new file mode 100644
index 0000000000..1ec410c4e7
--- /dev/null
+++ b/src/vt/collective/reduce/allreduce/rabenseifner.cc
@@ -0,0 +1,153 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                               rabenseifner.cc
+//                       DARMA/vt => Virtual Transport
+//
+// Copyright 2019-2024 National Technology & Engineering Solutions of Sandia, LLC
+// (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact darma@sandia.gov
+//
+// *****************************************************************************
+//@HEADER
+*/
+
+#include "vt/collective/reduce/allreduce/rabenseifner.h"
+#include "vt/collective/reduce/allreduce/allreduce_holder.h"
+#include "vt/collective/reduce/allreduce/rabenseifner_msg.h"
+#include "vt/collective/reduce/allreduce/type.h"
+#include "vt/configs/error/config_assert.h"
+#include "vt/group/group_manager.h"
+
+namespace vt::collective::reduce::allreduce {
+
+Rabenseifner::Rabenseifner(
+  detail::StrongVrtProxy proxy, detail::StrongGroup group, size_t num_elems)
+  : info_({ComponentT::VrtColl, proxy.get()}),
+    local_num_elems_(num_elems),
+    nodes_(theGroup()->GetGroupNodes(group.get())),
+    num_nodes_(nodes_.size()),
+    this_node_(theContext()->getNode()),
+    num_steps_(static_cast<int32_t>(std::log2(num_nodes_))),
+    nprocs_pof2_(1 << num_steps_),
+    nprocs_rem_(num_nodes_ - nprocs_pof2_) {
+
+  auto const is_default_group = theGroup()->isGroupDefault(group.get());
+  if (not is_default_group) {
+    auto it = std::find(nodes_.begin(), nodes_.end(), theContext()->getNode());
+    vtAssert(it != nodes_.end(), fmt::format("This node was not found in group nodes! Size={}", nodes_.size()));
+
+    this_node_ = it - nodes_.begin();
+  }
+
+  is_even_ = this_node_ % 2 == 0;
+  initializeVrtNode();
+
+  vt_debug_print(
+    terse, allreduce,
+    "Rabenseifner (this={}): proxy={:x} local_num_elems={}\n",
+    print_ptr(this), proxy.get(), local_num_elems_);
+}
+
+Rabenseifner::Rabenseifner(detail::StrongGroup group)
+  : info_({ComponentT::Group, group.get()}),
+    local_num_elems_(1),
+    nodes_(theGroup()->GetGroupNodes(group.get())),
+    num_nodes_(nodes_.size()),
+    this_node_(theContext()->getNode()),
+    num_steps_(static_cast<int32_t>(log2(num_nodes_))),
+    nprocs_pof2_(1 << num_steps_),
+    nprocs_rem_(num_nodes_ - nprocs_pof2_) {
+  auto const is_default_group = theGroup()->isGroupDefault(group.get());
+  auto const in_group = theGroup()->inGroup(group.get());
+  auto const is_part_of_allreduce =
+    (not is_default_group and in_group) or is_default_group;
+
+  vt_debug_print(
+    terse, allreduce,
+    "Rabenseifner: is_default_group={} is_part_of_allreduce={} \n",
+    is_default_group, is_part_of_allreduce);
+
+  if (not is_default_group and in_group) {
+    auto it = std::find(nodes_.begin(), nodes_.end(), theContext()->getNode());
+
+    vtAssert(it != nodes_.end(), "This node was not found in group nodes!");
+
+    // index in group list
+    this_node_ = it - nodes_.begin();
+  }
+
+  // We collectively create this Reducer, so it's possible that not all Nodes are part of it
+  if (is_part_of_allreduce) {
+    is_even_ = this_node_ % 2 == 0;
+
+    initializeVrtNode();
+  }
+}
+
+Rabenseifner::Rabenseifner(detail::StrongObjGroup objgroup)
+  : info_({ComponentT::ObjGroup, objgroup.get()}),
+    local_num_elems_(1),
+    num_nodes_(theContext()->getNumNodes()),
+    this_node_(theContext()->getNode()),
+    num_steps_(static_cast<int32_t>(log2(num_nodes_))),
+    nprocs_pof2_(1 << num_steps_),
+    nprocs_rem_(num_nodes_ - nprocs_pof2_) {
+
+  nodes_.resize(num_nodes_);
+  for (NodeType i = 0; i < theContext()->getNumNodes(); ++i) {
+    nodes_[i] = i;
+  }
+
+  initializeVrtNode();
+
+  vt_debug_print(
+    terse, allreduce,
+    "Rabenseifner: is_default_group={} is_part_of_allreduce={} num_nodes_={} \n",
+    true, true, num_nodes_);
+}
+
+void Rabenseifner::initializeVrtNode() {
+  is_even_ = this_node_ % 2 == 0;
+  is_part_of_adjustment_group_ = this_node_ < (2 * nprocs_rem_);
+  if (is_part_of_adjustment_group_) {
+    if (is_even_) {
+      vrt_node_ = this_node_ / 2;
+    } else {
+      vrt_node_ = -1;
+    }
+  } else {
+    vrt_node_ = this_node_ - nprocs_rem_;
+  }
+}
+
+} // namespace vt::collective::reduce::allreduce
diff --git a/src/vt/collective/reduce/allreduce/rabenseifner.h b/src/vt/collective/reduce/allreduce/rabenseifner.h
new file mode 100644
index 0000000000..9940f7fa4f
--- /dev/null
+++ b/src/vt/collective/reduce/allreduce/rabenseifner.h
@@ -0,0 +1,381 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                                rabenseifner.h
+//                       DARMA/vt => Virtual Transport
+//
+// Copyright 2019-2024 National Technology & Engineering Solutions of Sandia, LLC
+// (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact darma@sandia.gov
+//
+// *****************************************************************************
+//@HEADER
+*/
+
+#if !defined INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_RABENSEIFNER_H
+#define INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_RABENSEIFNER_H
+
+#include "vt/objgroup/proxy/proxy_objgroup.h"
+#include "type.h"
+#include "rabenseifner_msg.h"
+#include "vt/configs/types/types_type.h"
+
+#include <cstdint>
+
+namespace vt::collective::reduce::allreduce {
+
+/**
+ * \struct Rabenseifner
+ * \brief Class implementing Rabenseifner's allreduce algorithm.
+ *
+ * This class performs an allreduce operation using Rabenseifner's method. The algorithm consists
+ * of several phases: adjustment for power-of-two processes, scatter-reduce, and gather-allgather.
+ */
+
+struct Rabenseifner {
+  /**
+   * \brief Constructor for Collection
+   *
+   * \param proxy Collection proxy
+   * \param group GroupID (for given collection)
+   * \param num_elems Number of local collection elements
+   */
+  Rabenseifner(detail::StrongVrtProxy proxy, detail::StrongGroup group, size_t num_elems);
+
+  /**
+   * \brief Constructor for Group
+   *
+   * \param group GroupID
+   */
+  Rabenseifner(detail::StrongGroup group);
+
+  /**
+   * \brief Constructor for ObjGroup
+   *
+   * \param objgroup ObjGroupProxy
+   */
+  Rabenseifner(detail::StrongObjGroup objgroup);
+
+  void initializeVrtNode();
+
+  /**
+   * \brief Set final handler that will be executed with allreduce result
+   *
+   * \param fin Callback to be executed
+   * \param id Allreduce ID
+   */
+  template <typename DataT, typename CallbackType>
+  void setFinalHandler(const CallbackType& fin, size_t id);
+
+  template <typename DataT, template <typename Arg> class Op, typename... Args>
+  void storeData(size_t id, Args&&... args);
+
+  /**
+   * \brief Performs local reduce, and once the local one is done it starts up the global allreduce
+   *
+   * \param id Allreduce ID
+   * \param args Data to be allreduced
+   */
+  template <typename DataT, template <typename Arg> class Op>
+  void run(size_t id);
+
+  /**
+   * \brief Initialize the allreduce algorithm.
+   *
+   * This function sets up the necessary data structures and initial values for the reduction operation.
+   *
+   * \param id Allreduce ID
+   * \param args Additional arguments for initializing the data value.
+   */
+  template <typename DataT, typename ...Args>
+  void initialize(size_t id, Args&&... args);
+
+  /**
+   * \brief Initialize the internal state of allreduce algorithm.
+   *
+   * \param id Allreduce ID
+   */
+  template <typename DataT>
+  void initializeState(size_t id);
+
+  /**
+   * \brief Execute the final handler callback with the reduced result.
+   *
+   * \param id Allreduce ID
+   */
+  template <typename DataT>
+  void executeFinalHan(size_t id);
+
+  /**
+   * \brief Perform the allreduce operation.
+   *
+   * This function starts the allreduce operation, adjusting for non-power-of-two process counts if necessary.
+   *
+   * \param id Allreduce ID
+   */
+  template <typename DataT, template <typename Arg> class Op>
+  void allreduce(size_t id);
+
+  /**
+   * \brief Adjust the process count to the nearest power-of-two.
+   *
+   * This function performs additional steps to handle non-power-of-two process counts, ensuring that the
+   * main scatter-reduce and gather-allgather phases can proceed with a power-of-two number of processes.
+   *
+   * \param id Allreduce ID
+   */
+  template <typename DataT, template <typename Arg> class Op>
+  void adjustForPowerOfTwo(size_t id);
+
+  /**
+   * \brief Handler for adjusting the right half of the process group.
+   *
+   * This function handles the data received from the partner process and combines it using the reduction operation.
+   *
+   * \param msg Message containing the data from the partner process.
+   */
+  template <typename DataT, typename Scalar, template <typename Arg> class Op>
+  void adjustForPowerOfTwoRightHalf(RabenseifnerMsg<Scalar, DataT>* msg);
+
+  template <typename DataT, typename Scalar, template <typename Arg> class Op>
+  static void adjustForPowerOfTwoRightHalfHandler(RabenseifnerMsg<Scalar, DataT>* msg);
+
+  /**
+   * \brief Handler for adjusting the left half of the process group.
+   *
+   * This function handles the data received from the partner process and combines it using the reduction operation.
+   *
+   * \param msg Message containing the data from the partner process.
+   */
+  template <typename DataT, typename Scalar, template <typename Arg> class Op>
+  void adjustForPowerOfTwoLeftHalf(RabenseifnerMsg<Scalar, DataT>* msg);
+
+  template <typename DataT, typename Scalar, template <typename Arg> class Op>
+  static void adjustForPowerOfTwoLeftHalfHandler(RabenseifnerMsg<Scalar, DataT>* msg);
+  /**
+   * \brief Final adjustment step for non-power-of-two process counts.
+   *
+   * This function handles the final step of the adjustment phase, combining the data and proceeding to the next phase.
+   *
+   * \param msg Message containing the data from the partner process.
+   */
+  template <typename DataT, typename Scalar, template <typename Arg> class Op>
+  void adjustForPowerOfTwoFinalPart(RabenseifnerMsg<Scalar, DataT>* msg);
+
+  template <typename DataT, typename Scalar, template <typename Arg> class Op>
+  static void adjustForPowerOfTwoFinalPartHandler(RabenseifnerMsg<Scalar, DataT>* msg);
+  /**
+   * \brief Check if all scatter messages have been received.
+   *
+   * \param id Allreduce ID
+   * \return True if all scatter messages have been received, false otherwise.
+   */
+  template <typename DataT>
+  bool scatterAllMessagesReceived(size_t id);
+
+  /**
+   * \brief Check if the scatter phase is complete.
+   *
+   * \param id Allreduce ID
+   * \return True if the scatter phase is complete, false otherwise.
+   */
+  template <typename DataT>
+  bool scatterIsDone(size_t id);
+
+  /**
+   * \brief Check if the scatter phase is ready to proceed.
+   *
+   * \param id Allreduce ID
+   * \return True if the scatter phase is ready to proceed, false otherwise.
+   */
+  template <typename DataT>
+  bool scatterIsReady(size_t id);
+
+  /**
+   * \brief Try to reduce the received scatter messages.
+   *
+   * \param step The current step in the scatter phase.
+   */
+  template <typename DataT, template <typename Arg> class Op>
+  void scatterTryReduce(size_t id, int32_t step);
+
+  /**
+   * \brief Perform the scatter-reduce iteration.
+   *
+   * This function sends data to the appropriate partner process and proceeds to the next step in the scatter phase.
+   *
+   * \param id Allreduce ID
+   */
+  template <typename DataT, template <typename Arg> class Op>
+  void scatterReduceIter(size_t id);
+
+  /**
+   * \brief Handler for receiving scatter-reduce messages.
+   *
+   * This function handles the data received during the scatter-reduce phase and combines it using the reduction operation.
+   *
+   * \param msg Message containing the data from the partner process.
+   */
+  template <typename DataT, typename Scalar, template <typename Arg> class Op>
+  static void scatterReduceIterHandler(RabenseifnerMsg<Scalar, DataT>* msg);
+
+  template <typename DataT, typename Scalar, template <typename Arg> class Op>
+  void scatterHandler(RabenseifnerMsg<Scalar, DataT>* msg);
+
+  /**
+   * \brief Check if all gather messages have been received.
+   *
+   * \param id Allreduce ID
+   * \return True if all gather messages have been received, false otherwise.
+   */
+  template <typename DataT>
+  bool gatherAllMessagesReceived(size_t id);
+
+  /**
+   * \brief Check if the gather phase is complete.
+   *
+   * \param id Allreduce ID
+   * \return True if the gather phase is complete, false otherwise.
+   */
+  template <typename DataT>
+  bool gatherIsDone(size_t id);
+
+  /**
+   * \brief Check if the gather phase is ready to proceed.
+   *
+   * \param id Allreduce ID
+   * \return True if the gather phase is ready to proceed, false otherwise.
+   */
+  template <typename DataT>
+  bool gatherIsReady(size_t id);
+
+  /**
+   * \brief Try to reduce the received gather messages.
+   *
+   * \param id Allreduce ID
+   * \param step The current step in the gather phase.
+   */
+  template <typename DataT>
+  void gatherTryReduce(size_t id, int32_t step);
+
+  /**
+   * \brief Perform the gather iteration.
+   *
+   * This function sends data to the appropriate partner process and proceeds to the next step in the gather phase.
+   *
+   * \param id Allreduce ID
+   */
+  template <typename DataT>
+  void gatherIter(size_t id);
+
+  /**
+   * \brief Handler for receiving gather messages.
+   *
+   * This function handles the data received during the gather phase and combines it using the reduction operation.
+   *
+   * \param msg Message containing the data from the partner process.
+   */
+  template <typename DataT, typename Scalar>
+  static void gatherIterHandler(RabenseifnerMsg<Scalar, DataT>* msg);
+
+  template <typename DataT, typename Scalar>
+  void gatherIterHan(RabenseifnerMsg<Scalar, DataT>* msg);
+
+  /**
+   * \brief Perform the final part of the allreduce operation.
+   *
+   * This function completes the allreduce operation, handling any remaining steps and invoking the final handler.
+   *
+   * \param id Allreduce ID
+   */
+  template <typename DataT>
+  void finalPart(size_t id);
+
+  /**
+   * \brief Send the result to excluded nodes.
+   *
+   * This function handles the final step for non-power-of-two process counts, sending the reduced result to excluded nodes.
+   *
+   * \param id Allreduce ID
+   */
+  template <typename DataT>
+  void sendToExcludedNodes(size_t id);
+
+  /**
+   * \brief Handler for receiving the final result on excluded nodes.
+   *
+   * This function handles the data received on excluded nodes and invokes the final handler.
+   *
+   * \param msg Message containing the final result.
+   */
+  template <typename DataT, typename Scalar>
+  static void sendToExcludedNodesHandler(RabenseifnerMsg<Scalar, DataT>* msg);
+
+  template <typename DataT, typename Scalar>
+  void sendToExcludedNodesHan(RabenseifnerMsg<Scalar, DataT>* msg);
+
+  ComponentInfo info_ = {};
+
+  size_t local_num_elems_ = {};
+
+  /// Sorted list of Nodes that take part in allreduce
+  std::vector<NodeType> nodes_ = {};
+
+  NodeType num_nodes_ = {};
+
+  /// Represents an index inside nodes_
+  NodeType this_node_ = {};
+
+  bool is_even_ = false;
+
+  /// Num steps for each scatter/gather phase
+  int32_t num_steps_ = {};
+
+  /// 2^num_steps_
+  int32_t nprocs_pof2_ = {};
+  int32_t nprocs_rem_ = {};
+
+  /// For non-power-of-2 number of nodes this respresents whether current Node
+  /// is excluded (has value of -1) from computation
+  NodeType vrt_node_ = {};
+
+  bool is_part_of_adjustment_group_ = false;
+
+  static inline const std::string name_ = "Rabenseifner";
+  static inline constexpr ReducerType type_ = ReducerType::Rabenseifner;
+};
+
+} // namespace vt::collective::reduce::allreduce
+
+#include "rabenseifner.impl.h"
+
+#endif /*INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_RABENSEIFNER_H*/
diff --git a/src/vt/collective/reduce/allreduce/rabenseifner.impl.h b/src/vt/collective/reduce/allreduce/rabenseifner.impl.h
new file mode 100644
index 0000000000..4063228b2a
--- /dev/null
+++ b/src/vt/collective/reduce/allreduce/rabenseifner.impl.h
@@ -0,0 +1,733 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                             rabenseifner.impl.h
+//                       DARMA/vt => Virtual Transport
+//
+// Copyright 2019-2024 National Technology & Engineering Solutions of Sandia, LLC
+// (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact darma@sandia.gov
+//
+// *****************************************************************************
+//@HEADER
+*/
+
+#if !defined INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_RABENSEIFNER_IMPL_H
+#define INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_RABENSEIFNER_IMPL_H
+
+#include "vt/collective/reduce/allreduce/rabenseifner.h"
+#include "vt/collective/reduce/allreduce/data_handler.h"
+#include "vt/collective/reduce/allreduce/helpers.h"
+#include "vt/config.h"
+#include "vt/context/context.h"
+#include "vt/configs/error/config_assert.h"
+#include "vt/group/global/group_default.h"
+#include "vt/configs/types/types_sentinels.h"
+#include "vt/registry/auto/auto_registry.h"
+#include "vt/utils/fntraits/fntraits.h"
+#include "vt/configs/debug/debug_print.h"
+#include "vt/configs/debug/debug_printconst.h"
+#include "vt/collective/reduce/allreduce/type.h"
+#include "vt/collective/reduce/allreduce/state_holder.h"
+#include "vt/collective/reduce/scoping/strong_types.h"
+#include "vt/configs/types/types_type.h"
+#include "vt/collective/reduce/allreduce/allreduce_holder.h"
+#include "vt/topos/location/location.impl.h"
+
+#include <string>
+#include <type_traits>
+
+namespace vt::collective::reduce::allreduce {
+
+template <typename DataT, typename CallbackType>
+void Rabenseifner::setFinalHandler(const CallbackType& fin, size_t id) {
+  auto& state = getState<RabenseifnerT, DataT>(info_, id);
+  state.final_handler_ = fin;
+}
+
+template <typename DataT, template <typename Arg> class Op, typename... Args>
+void Rabenseifner::storeData(size_t id, Args&&... data) {
+  using DataHelperT = DataHelper<typename DataHandler<DataT>::Scalar, DataT>;
+  auto& state = getState<RabenseifnerT, DataT>(info_, id);
+
+  vt_debug_print(
+    terse, allreduce,
+    "Rabenseifner(ID = {}) storeData: local_col_wait_count_={} "
+    "initialized={}\n",
+    id, state.local_col_wait_count_, state.initialized_);
+
+  if (DataHelperT::empty(state.val_)) {
+    initialize<DataT>(id, std::forward<Args>(data)...);
+  } else {
+    DataHelper<typename DataHandler<DataT>::Scalar, DataT>::template reduce<Op>(
+      state.val_, std::forward<Args>(data)...);
+  }
+
+  state.local_col_wait_count_++;
+}
+
+template <typename DataT, template <typename Arg> class Op>
+void Rabenseifner::run(size_t id) {
+  auto& state = getState<RabenseifnerT, DataT>(info_, id);
+  auto const is_ready = state.local_col_wait_count_ == local_num_elems_;
+
+  if (is_ready) {
+    // Execute early in case we're the only node
+    if (num_nodes_ < 2) {
+      executeFinalHan<DataT>(id);
+    } else {
+      allreduce<DataT, Op>(id);
+    }
+  }
+}
+
+template <typename DataT>
+void Rabenseifner::initializeState(size_t id) {
+  auto& state = getState<RabenseifnerT, DataT>(info_, id);
+
+  vt_debug_print(
+    terse, allreduce,
+    "Rabenseifner initializing state for ID = {} num_steps_ = {}\n", id,
+    num_steps_);
+
+  state.finished_adjustment_part_ = not is_part_of_adjustment_group_;
+  state.completed_ = false;
+
+  state.scatter_mask_ = 1;
+  state.scatter_step_ = 0;
+  state.finished_scatter_part_ = false;
+
+  state.gather_step_ = num_steps_ - 1;
+  state.gather_mask_ = nprocs_pof2_ >> 1;
+  state.gather_num_recv_ = 0;
+
+  state.scatter_messages_.resize(num_steps_, nullptr);
+  state.scatter_steps_recv_.resize(num_steps_, false);
+  state.scatter_steps_reduced_.resize(num_steps_, false);
+
+  state.gather_messages_.resize(num_steps_, nullptr);
+  state.gather_steps_recv_.resize(num_steps_, false);
+  state.gather_steps_reduced_.resize(num_steps_, false);
+
+  state.r_index_.resize(num_steps_, 0);
+  state.r_count_.resize(num_steps_, 0);
+  state.s_index_.resize(num_steps_, 0);
+  state.s_count_.resize(num_steps_, 0);
+
+  state.initialized_ = true;
+}
+
+template <typename DataT, typename... Args>
+void Rabenseifner::initialize(size_t id, Args&&... data) {
+  auto& state = getState<RabenseifnerT, DataT>(info_, id);
+
+  DataHelper<typename DataHandler<DataT>::Scalar, DataT>::assign(
+    state.val_, std::forward<Args>(data)...);
+
+  if (not state.initialized_) {
+    initializeState<DataT>(id);
+  }
+
+  int step = 0;
+  state.size_ = state.val_.size();
+  auto size = state.size_;
+  for (int mask = 1; mask < nprocs_pof2_; mask <<= 1) {
+    auto vdest = vrt_node_ ^ mask;
+    auto dest = (vdest < nprocs_rem_) ? vdest * 2 : vdest + nprocs_rem_;
+
+    if (this_node_ < dest) {
+      state.r_count_[step] = size / 2;
+      state.s_count_[step] = size - state.r_count_[step];
+      state.s_index_[step] = state.r_index_[step] + state.r_count_[step];
+    } else {
+      state.s_count_[step] = size / 2;
+      state.r_count_[step] = size - state.s_count_[step];
+      state.r_index_[step] = state.s_index_[step] + state.s_count_[step];
+    }
+
+    if (step + 1 < num_steps_) {
+      state.r_index_[step + 1] = state.r_index_[step];
+      state.s_index_[step + 1] = state.r_index_[step];
+      size = state.r_count_[step];
+      step++;
+    }
+  }
+
+  state.active_ = true;
+
+  vt_debug_print(
+    terse, allreduce,
+    "Rabenseifner initialize: size_ = {} num_steps_ = {} nprocs_pof2_ = {} "
+    "nprocs_rem_ = "
+    "{} "
+    "is_part_of_adjustment_group_ = {} vrt_node_ = {} ID = {} state = {}\n",
+    state.size_, num_steps_, nprocs_pof2_, nprocs_rem_,
+    is_part_of_adjustment_group_, vrt_node_, id, print_ptr(&state));
+}
+
+template <typename DataT>
+void Rabenseifner::executeFinalHan(size_t id) {
+  auto& state = getState<RabenseifnerT, DataT>(info_, id);
+
+  vt_debug_print(
+    terse, allreduce, "Rabenseifner executing final handler ID = {}\n", id);
+  vtAssert(state.final_handler_.valid(), "Final handler is not set!");
+
+  if constexpr (ShouldUseView_v<typename DataHandler<DataT>::Scalar, DataT>) {
+    state.final_handler_.send(state.val_);
+  } else {
+    state.final_handler_.send(
+      std::move(DataHandler<DataT>::fromVec(state.val_)));
+  }
+
+  state.completed_ = true;
+  cleanupState(info_, id);
+}
+
+template <typename DataT, template <typename Arg> class Op>
+void Rabenseifner::allreduce(size_t id) {
+  if (is_part_of_adjustment_group_) {
+    adjustForPowerOfTwo<DataT, Op>(id);
+  } else {
+    scatterReduceIter<DataT, Op>(id);
+  }
+}
+
+template <typename DataT, template <typename Arg> class Op>
+void Rabenseifner::adjustForPowerOfTwo(size_t id) {
+  if (is_part_of_adjustment_group_) {
+    using Scalar = typename DataHandler<DataT>::Scalar;
+    using DataHelperT = DataHelper<Scalar, DataT>;
+    auto& state = getState<RabenseifnerT, DataT>(info_, id);
+
+    auto const partner = is_even_ ? this_node_ + 1 : this_node_ - 1;
+    auto const actual_partner = nodes_[partner];
+
+    vt_debug_print(
+      terse, allreduce, "Rabenseifner AdjustInitial (To {}): ID = {}\n",
+      actual_partner, id);
+
+    if (is_even_) {
+      theMsg()->sendMsg<adjustForPowerOfTwoRightHalfHandler<DataT, Scalar, Op>>(
+        actual_partner,
+        DataHelperT::createMessage(
+          info_, state.val_, state.size_ / 2, state.size_ - (state.size_ / 2),
+          id));
+
+      if (state.left_adjust_message_ != nullptr) {
+        adjustForPowerOfTwoLeftHalf<DataT, Scalar, Op>(
+          state.left_adjust_message_.get());
+      }
+    } else {
+      theMsg()->sendMsg<adjustForPowerOfTwoLeftHalfHandler<DataT, Scalar, Op>>(
+        actual_partner,
+        DataHelperT::createMessage(info_, state.val_, 0, state.size_ / 2, id));
+
+      if (state.right_adjust_message_ != nullptr) {
+        adjustForPowerOfTwoRightHalf<DataT, Scalar, Op>(
+          state.right_adjust_message_.get());
+      }
+    }
+  }
+}
+
+template <typename DataT, typename Scalar, template <typename Arg> class Op>
+/*static*/ void Rabenseifner::adjustForPowerOfTwoRightHalfHandler(
+  RabenseifnerMsg<Scalar, DataT>* msg) {
+  auto* reducer = getAllreducer<RabenseifnerT>(msg->info_);
+  if (reducer) {
+    reducer->template adjustForPowerOfTwoRightHalf<DataT, Scalar, Op>(msg);
+  } else {
+    // Reducer not created, store the message
+    auto& state = getState<RabenseifnerT, DataT>(msg->info_, msg->id_);
+    state.right_adjust_message_ = promoteMsg(msg);
+  }
+}
+
+template <typename DataT, typename Scalar, template <typename Arg> class Op>
+void Rabenseifner::adjustForPowerOfTwoRightHalf(
+  RabenseifnerMsg<Scalar, DataT>* msg) {
+  using DataHelperT = DataHelper<Scalar, DataT>;
+  auto& state = getState<RabenseifnerT, DataT>(info_, msg->id_);
+
+  if (DataHelperT::empty(state.val_)) {
+    if (not state.initialized_) {
+      vt_debug_print(
+        verbose, allreduce,
+        "Rabenseifner AdjustRightHalf (From {}): State not initialized ID "
+        "{}!\n",
+        theContext()->getFromNodeCurrentTask(), msg->id_);
+
+      initializeState<DataT>(msg->id_);
+    }
+    state.right_adjust_message_ = promoteMsg(msg);
+
+    return;
+  }
+
+  vt_debug_print(
+    terse, allreduce, "Rabenseifner AdjustRightHalf (From {}): ID = {}\n",
+    theContext()->getFromNodeCurrentTask(), msg->id_);
+
+  DataHelperT::template reduceMsg<Op>(state.val_, state.size_ / 2, msg);
+
+  // Send to left node
+  auto const actual_partner = nodes_[this_node_ - 1];
+  theMsg()->sendMsg<adjustForPowerOfTwoFinalPartHandler<DataT, Scalar, Op>>(
+    actual_partner,
+    DataHelperT::createMessage(
+      info_, state.val_, state.size_ / 2, state.size_ - (state.size_ / 2),
+      msg->id_));
+}
+
+template <typename DataT, typename Scalar, template <typename Arg> class Op>
+/*static*/ void Rabenseifner::adjustForPowerOfTwoLeftHalfHandler(
+  RabenseifnerMsg<Scalar, DataT>* msg) {
+  getAllreducer<RabenseifnerT>(msg->info_)
+    ->template adjustForPowerOfTwoLeftHalf<DataT, Scalar, Op>(msg);
+}
+
+template <typename DataT, typename Scalar, template <typename Arg> class Op>
+void Rabenseifner::adjustForPowerOfTwoLeftHalf(
+  RabenseifnerMsg<Scalar, DataT>* msg) {
+  using DataHelperT = DataHelper<typename DataHandler<DataT>::Scalar, DataT>;
+  auto& state = getState<RabenseifnerT, DataT>(info_, msg->id_);
+  if (DataHelperT::empty(state.val_)) {
+    if (not state.initialized_) {
+      vt_debug_print(
+        verbose, allreduce,
+        "Rabenseifner AdjustLeftHalf (From {}): State not initialized ID {}!\n",
+        theContext()->getFromNodeCurrentTask(), msg->id_);
+
+      initializeState<DataT>(msg->id_);
+    }
+    state.left_adjust_message_ = promoteMsg(msg);
+
+    return;
+  }
+
+  vt_debug_print(
+    terse, allreduce, "Rabenseifner AdjustLeftHalf (From {}): ID = {}\n",
+    theContext()->getFromNodeCurrentTask(), msg->id_);
+
+  DataHelperT::template reduceMsg<Op>(state.val_, 0, msg);
+}
+
+template <typename DataT, typename Scalar, template <typename Arg> class Op>
+/*static*/ void Rabenseifner::adjustForPowerOfTwoFinalPartHandler(
+  RabenseifnerMsg<Scalar, DataT>* msg) {
+    auto* reducer = getAllreducer<RabenseifnerT>(msg->info_);
+  if (reducer) {
+    reducer->template adjustForPowerOfTwoFinalPart<DataT, Scalar, Op>(msg);
+  } else {
+    // Reducer not created, store the message
+    auto& state = getState<RabenseifnerT, DataT>(msg->info_, msg->id_);
+    state.left_adjust_message_ = promoteMsg(msg);
+  }
+}
+
+template <typename DataT, typename Scalar, template <typename Arg> class Op>
+void Rabenseifner::adjustForPowerOfTwoFinalPart(
+  RabenseifnerMsg<Scalar, DataT>* msg) {
+  vt_debug_print(
+    terse, allreduce, "Rabenseifner AdjustFinal (From {}): ID = {}\n",
+    theContext()->getFromNodeCurrentTask(), msg->id_);
+
+  using DataHelperT = DataHelper<typename DataHandler<DataT>::Scalar, DataT>;
+  auto& state = getState<RabenseifnerT, DataT>(info_, msg->id_);
+
+  DataHelperT::copy(state.val_, state.size_ / 2, msg);
+
+  state.finished_adjustment_part_ = true;
+
+  scatterReduceIter<DataT, Op>(msg->id_);
+}
+
+template <typename DataT>
+bool Rabenseifner::scatterAllMessagesReceived(size_t id) {
+  auto& state = getState<RabenseifnerT, DataT>(info_, id);
+
+  return std::all_of(
+    state.scatter_steps_recv_.cbegin(),
+    state.scatter_steps_recv_.cbegin() + state.scatter_step_,
+    [](auto const val) { return val; });
+}
+
+template <typename DataT>
+bool Rabenseifner::scatterIsDone(size_t id) {
+  auto& state = getState<RabenseifnerT, DataT>(info_, id);
+  return (state.scatter_step_ == num_steps_) and
+    (state.scatter_num_recv_ == num_steps_);
+}
+
+template <typename DataT>
+bool Rabenseifner::scatterIsReady(size_t id) {
+  auto& state = getState<RabenseifnerT, DataT>(info_, id);
+  return ((is_part_of_adjustment_group_ and state.finished_adjustment_part_) and
+          state.scatter_step_ == 0) or
+    ((state.scatter_mask_ < nprocs_pof2_) and
+     scatterAllMessagesReceived<DataT>(id));
+}
+
+template <typename DataT, template <typename Arg> class Op>
+void Rabenseifner::scatterTryReduce(size_t id, int32_t step) {
+  using DataHelperT = DataHelper<typename DataHandler<DataT>::Scalar, DataT>;
+  auto& state = getState<RabenseifnerT, DataT>(info_, id);
+
+  auto do_reduce = (step < state.scatter_step_) and
+    not state.scatter_steps_reduced_[step] and
+    state.scatter_steps_recv_[step] and
+    std::all_of(state.scatter_steps_reduced_.cbegin(),
+                state.scatter_steps_reduced_.cbegin() + step,
+                [](auto const val) { return val; });
+
+  vt_debug_print(
+    verbose, allreduce,
+    "Rabenseifner ScatterTryReduce (Step = {} ID = {}): {}\n", step, id,
+    do_reduce);
+
+  if (do_reduce) {
+    auto& in_msg = state.scatter_messages_.at(step);
+    DataHelperT::template reduceMsg<Op>(
+      state.val_, state.r_index_[in_msg->step_], in_msg.get());
+
+    state.scatter_steps_reduced_[step] = true;
+  }
+}
+
+template <typename DataT, template <typename Arg> class Op>
+void Rabenseifner::scatterReduceIter(size_t id) {
+  if (not scatterIsReady<DataT>(id)) {
+    return;
+  }
+
+  using Scalar = typename DataHandler<DataT>::Scalar;
+  using DataHelperT = DataHelper<Scalar, DataT>;
+  auto& state = getState<RabenseifnerT, DataT>(info_, id);
+
+  auto vdest = vrt_node_ ^ state.scatter_mask_;
+  auto dest = (vdest < nprocs_rem_) ? vdest * 2 : vdest + nprocs_rem_;
+  auto const actual_partner = nodes_[dest];
+
+  vt_debug_print(
+    terse, allreduce,
+    "Rabenseifner Scatter (Send step {} to {}): Starting with idx = {} and "
+    "count "
+    "{} ID = {} \n",
+    state.scatter_step_, actual_partner, state.s_index_[state.scatter_step_],
+    state.s_count_[state.scatter_step_], id);
+
+  theMsg()->template sendMsg<scatterReduceIterHandler<DataT, Scalar, Op>>(
+    actual_partner,
+    DataHelperT::createMessage(
+      info_, state.val_, state.s_index_[state.scatter_step_],
+      state.s_count_[state.scatter_step_], id, state.scatter_step_));
+
+  state.scatter_mask_ <<= 1;
+  state.scatter_step_++;
+
+  scatterTryReduce<DataT, Op>(id, state.scatter_step_ - 1);
+
+  if (scatterIsDone<DataT>(id)) {
+    state.finished_scatter_part_ = true;
+    gatherIter<DataT>(id);
+  } else {
+    scatterReduceIter<DataT, Op>(id);
+  }
+}
+
+template <typename DataT, typename Scalar, template <typename Arg> class Op>
+/*static*/ void
+Rabenseifner::scatterReduceIterHandler(RabenseifnerMsg<Scalar, DataT>* msg) {
+  auto* reducer = getAllreducer<RabenseifnerT>(msg->info_);
+
+  vt_debug_print(
+    terse, allreduce,
+    "Rabenseifner::scatterReduceIterHandler reducer={} ID={} \n",
+    (reducer != nullptr), msg->id_
+  );
+
+  if (reducer) {
+    reducer->template scatterHandler<DataT, Scalar, Op>(msg);
+  } else {
+    // Reducer not created, store the message
+    auto& state = getState<RabenseifnerT, DataT>(msg->info_, msg->id_);
+
+    if(state.scatter_messages_.size() < static_cast<size_t>(msg->step_ + 1)){
+      state.scatter_messages_.resize(msg->step_ + 1, nullptr);
+    }
+
+    if(state.scatter_steps_recv_.size() < static_cast<size_t>(msg->step_ + 1)){
+      state.scatter_steps_recv_.resize(msg->step_ + 1, false);
+    }
+
+    state.scatter_messages_[msg->step_] = promoteMsg(msg);
+    state.scatter_steps_recv_[msg->step_] = true;
+    state.scatter_num_recv_++;
+  }
+}
+
+template <typename DataT, typename Scalar, template <typename Arg> class Op>
+void Rabenseifner::scatterHandler(RabenseifnerMsg<Scalar, DataT>* msg) {
+  using DataHelperT = DataHelper<typename DataHandler<DataT>::Scalar, DataT>;
+
+  auto& state = getState<RabenseifnerT, DataT>(info_, msg->id_);
+
+  if (DataHelperT::empty(state.val_)) {
+    if (not state.initialized_) {
+      vt_debug_print(
+        verbose, allreduce,
+        "Rabenseifner Scatter (Recv step {} from {}): State not initialized "
+        "for ID = "
+        "{}!\n",
+        msg->step_, theContext()->getFromNodeCurrentTask(), msg->id_);
+      initializeState<DataT>(msg->id_);
+    }
+
+    state.scatter_messages_[msg->step_] = promoteMsg(msg);
+    state.scatter_steps_recv_[msg->step_] = true;
+    state.scatter_num_recv_++;
+
+    return;
+  }
+
+  vt_debug_print(
+    terse, allreduce,
+    "Rabenseifner Scatter (Recv step {} from {}): initialized = {} "
+    "scatter_mask_= {} nprocs_pof2_ = {}: scatterAllMessagesReceived() = {} "
+    "state.finished_adjustment_part_ = {} "
+    "idx = {} ID = {}\n",
+    msg->step_, theContext()->getFromNodeCurrentTask(), state.initialized_,
+    state.scatter_mask_, nprocs_pof2_,
+    scatterAllMessagesReceived<DataT>(msg->id_),
+    state.finished_adjustment_part_, state.r_index_[msg->step_], msg->id_);
+
+  state.scatter_messages_[msg->step_] = promoteMsg(msg);
+  state.scatter_steps_recv_[msg->step_] = true;
+  state.scatter_num_recv_++;
+
+  if (not state.finished_adjustment_part_) {
+    return;
+  }
+
+  scatterTryReduce<DataT, Op>(msg->id_, msg->step_);
+
+  if (
+    (state.scatter_mask_ < nprocs_pof2_) and
+    scatterAllMessagesReceived<DataT>(msg->id_)) {
+    scatterReduceIter<DataT, Op>(msg->id_);
+  } else if (scatterIsDone<DataT>(msg->id_)) {
+    state.finished_scatter_part_ = true;
+    gatherIter<DataT>(msg->id_);
+  }
+}
+
+template <typename DataT>
+bool Rabenseifner::gatherAllMessagesReceived(size_t id) {
+  auto& state = getState<RabenseifnerT, DataT>(info_, id);
+  return std::all_of(
+    state.gather_steps_recv_.cbegin() + state.gather_step_ + 1,
+    state.gather_steps_recv_.cend(), [](auto const val) { return val; });
+}
+
+template <typename DataT>
+bool Rabenseifner::gatherIsDone(size_t id) {
+  auto& state = getState<RabenseifnerT, DataT>(info_, id);
+  return (state.gather_step_ < 0) and (state.gather_num_recv_ == num_steps_);
+}
+
+template <typename DataT>
+bool Rabenseifner::gatherIsReady(size_t id) {
+  auto& state = getState<RabenseifnerT, DataT>(info_, id);
+  return (state.gather_step_ == num_steps_ - 1) or
+    gatherAllMessagesReceived<DataT>(id);
+}
+
+template <typename DataT>
+void Rabenseifner::gatherTryReduce(size_t id, int32_t step) {
+  using DataHelperT = DataHelper<typename DataHandler<DataT>::Scalar, DataT>;
+  auto& state = getState<RabenseifnerT, DataT>(info_, id);
+
+  auto const doRed = (step > state.gather_step_) and
+    not state.gather_steps_reduced_[step] and state.gather_steps_recv_[step] and
+    std::all_of(state.gather_steps_reduced_.cbegin() + step + 1,
+                state.gather_steps_reduced_.cend(),
+                [](auto const val) { return val; });
+
+  if (doRed) {
+    auto& in_msg = state.gather_messages_.at(step);
+    DataHelperT::copy(state.val_, state.s_index_[in_msg->step_], in_msg.get());
+
+    state.gather_steps_reduced_[step] = true;
+  }
+}
+
+template <typename DataT>
+void Rabenseifner::gatherIter(size_t id) {
+  if (not gatherIsReady<DataT>(id)) {
+    return;
+  }
+
+  using Scalar = typename DataHandler<DataT>::Scalar;
+  using DataHelperT = DataHelper<Scalar, DataT>;
+  auto& state = getState<RabenseifnerT, DataT>(info_, id);
+  auto vdest = vrt_node_ ^ state.gather_mask_;
+  auto dest = (vdest < nprocs_rem_) ? vdest * 2 : vdest + nprocs_rem_;
+  auto const actual_partner = nodes_[dest];
+
+  vt_debug_print(
+    terse, allreduce,
+    "Rabenseifner Gather (step {}): Sending to Node {} starting with idx = {} "
+    "and "
+    "count "
+    "{} ID = {}\n",
+    state.gather_step_, actual_partner, state.r_index_[state.gather_step_],
+    state.r_count_[state.gather_step_], id);
+
+  theMsg()->template sendMsg<gatherIterHandler<DataT, Scalar>>(
+    actual_partner,
+    DataHelperT::createMessage(
+      info_, state.val_, state.r_index_[state.gather_step_],
+      state.r_count_[state.gather_step_], id, state.gather_step_));
+
+  state.gather_mask_ >>= 1;
+  state.gather_step_--;
+
+  gatherTryReduce<DataT>(id, state.gather_step_ + 1);
+
+  if (gatherIsDone<DataT>(id)) {
+    finalPart<DataT>(id);
+  } else if (gatherIsReady<DataT>(id)) {
+    gatherIter<DataT>(id);
+  }
+}
+
+template <typename DataT, typename Scalar>
+/*static*/ void
+Rabenseifner::gatherIterHandler(RabenseifnerMsg<Scalar, DataT>* msg) {
+  getAllreducer<RabenseifnerT>(msg->info_)
+    ->template gatherIterHan<DataT, Scalar>(msg);
+}
+
+template <typename DataT, typename Scalar>
+void Rabenseifner::gatherIterHan(RabenseifnerMsg<Scalar, DataT>* msg) {
+  auto& state = getState<RabenseifnerT, DataT>(info_, msg->id_);
+  vt_debug_print(
+    terse, allreduce,
+    "Rabenseifner Gather (Recv step {} from {}): idx = {} ID = {}\n",
+    msg->step_, theContext()->getFromNodeCurrentTask(),
+    state.s_index_[msg->step_], msg->id_);
+
+  state.gather_messages_[msg->step_] = promoteMsg(msg);
+  state.gather_steps_recv_[msg->step_] = true;
+  state.gather_num_recv_++;
+
+  if (not state.finished_scatter_part_) {
+    return;
+  }
+
+  gatherTryReduce<DataT>(msg->id_, msg->step_);
+
+  if (state.gather_mask_ > 0 and gatherIsReady<DataT>(msg->id_)) {
+    gatherIter<DataT>(msg->id_);
+  } else if (gatherIsDone<DataT>(msg->id_)) {
+    finalPart<DataT>(msg->id_);
+  }
+}
+
+template <typename DataT>
+void Rabenseifner::finalPart(size_t id) {
+  auto& state = getState<RabenseifnerT, DataT>(info_, id);
+  if (state.completed_) {
+    return;
+  }
+
+  if (nprocs_rem_) {
+    sendToExcludedNodes<DataT>(id);
+  }
+
+  vt_debug_print(
+    terse, allreduce,
+    "Rabenseifner::finalPart(): Executing final handler with size {} ID = {}\n",
+    state.val_.size(), id);
+
+  executeFinalHan<DataT>(id);
+}
+
+template <typename DataT>
+void Rabenseifner::sendToExcludedNodes(size_t id) {
+  using Scalar = typename DataHandler<DataT>::Scalar;
+  using DataHelperT = DataHelper<Scalar, DataT>;
+  auto& state = getState<RabenseifnerT, DataT>(info_, id);
+  if (is_part_of_adjustment_group_ and is_even_) {
+    auto const actual_partner = nodes_[this_node_ + 1];
+    vt_debug_print(
+      terse, allreduce,
+      "Rabenseifner::sendToExcludedNodes(): Sending to Node {} ID = {} "
+      "size={}\n",
+      actual_partner, id, state.size_);
+
+    theMsg()->sendMsg<sendToExcludedNodesHandler<DataT, Scalar>>(
+      actual_partner,
+      DataHelperT::createMessage(info_, state.val_, 0, state.size_, id));
+  }
+}
+
+template <typename DataT, typename Scalar>
+void Rabenseifner::sendToExcludedNodesHandler(
+  RabenseifnerMsg<Scalar, DataT>* msg) {
+  getAllreducer<RabenseifnerT>(msg->info_)
+    ->template sendToExcludedNodesHan<DataT, Scalar>(msg);
+}
+
+template <typename DataT, typename Scalar>
+void Rabenseifner::sendToExcludedNodesHan(RabenseifnerMsg<Scalar, DataT>* msg) {
+  vt_debug_print(
+    terse, allreduce,
+    "Rabenseifner::sendToExcludedNodesHandler(): Received allreduce result "
+    "with ID = {}\n",
+    msg->id_);
+
+  auto& state = getState<RabenseifnerT, DataT>(info_, msg->id_);
+  if constexpr (ShouldUseView_v<typename DataHandler<DataT>::Scalar, DataT>) {
+    state.val_ = msg->val_;
+  } else {
+    DataHelper<typename DataHandler<DataT>::Scalar, DataT>::assignFromMem(
+      state.val_, msg->val_, msg->size_);
+  }
+
+  executeFinalHan<DataT>(msg->id_);
+}
+
+} // namespace vt::collective::reduce::allreduce
+
+#endif /*INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_RABENSEIFNER_IMPL_H*/
diff --git a/src/vt/collective/reduce/allreduce/rabenseifner_msg.h b/src/vt/collective/reduce/allreduce/rabenseifner_msg.h
new file mode 100644
index 0000000000..efedba0af1
--- /dev/null
+++ b/src/vt/collective/reduce/allreduce/rabenseifner_msg.h
@@ -0,0 +1,137 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                              rabenseifner_msg.h
+//                       DARMA/vt => Virtual Transport
+//
+// Copyright 2019-2024 National Technology & Engineering Solutions of Sandia, LLC
+// (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact darma@sandia.gov
+//
+// *****************************************************************************
+//@HEADER
+*/
+
+#if !defined INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_RABENSEIFNER_MSG_H
+#define INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_RABENSEIFNER_MSG_H
+
+#include "vt/config.h"
+#include "vt/collective/reduce/operators/default_msg.h"
+#include "type.h"
+
+namespace vt::collective::reduce::allreduce {
+
+template <typename Scalar, typename DataT>
+struct RabenseifnerMsg : Message {
+  using MessageParentType = vt::Message;
+  vt_msg_serialize_required();
+
+  RabenseifnerMsg() = default;
+  RabenseifnerMsg(RabenseifnerMsg const&) = default;
+  RabenseifnerMsg(RabenseifnerMsg&&) = default;
+  ~RabenseifnerMsg() {
+    if (owning_) {
+      delete[] val_;
+    }
+  }
+
+  RabenseifnerMsg(ComponentInfo info, const Scalar* in_val, size_t size, size_t id, int step = 0)
+    : MessageParentType(),
+      val_(in_val),
+      size_(size),
+      id_(id),
+      step_(step),
+      info_(info) { }
+
+  template <typename SerializeT>
+  void serialize(SerializeT& s) {
+    MessageParentType::serialize(s);
+
+    s | size_;
+
+    if (s.isUnpacking()) {
+      owning_ = true;
+      val_ = new Scalar[size_];
+    }
+
+    checkpoint::dispatch::serializeArray(s, val_, size_);
+
+    s | id_;
+    s | step_;
+    s | info_;
+  }
+
+  const Scalar* val_ = {};
+  size_t size_ = {};
+  size_t id_ = {};
+  int32_t step_ = {};
+  bool owning_ = false;
+  ComponentInfo info_ = {};
+};
+
+#if MAGISTRATE_KOKKOS_ENABLED
+template <typename Scalar, typename... Properties>
+struct RabenseifnerMsg<Scalar, Kokkos::View<Scalar*, Properties...>> : Message {
+  using ViewT = Kokkos::View<Scalar*, Properties...>;
+  using MessageParentType = vt::Message;
+  vt_msg_serialize_required();
+
+  RabenseifnerMsg() = default;
+  RabenseifnerMsg(RabenseifnerMsg const&) = default;
+  RabenseifnerMsg(RabenseifnerMsg&&) = default;
+
+  RabenseifnerMsg(ComponentInfo info, const ViewT& in_val, size_t id, int step = 0)
+    : MessageParentType(),
+      val_(in_val),
+      id_(id),
+      step_(step),
+      info_(info) { }
+
+  template <typename SerializeT>
+  void serialize(SerializeT& s) {
+    MessageParentType::serialize(s);
+
+    s | val_;
+    s | id_;
+    s | step_;
+    s | info_;
+  }
+
+  ViewT val_ = {};
+  size_t id_ = {};
+  int32_t step_ = {};
+  ComponentInfo info_ = {};
+};
+#endif // MAGISTRATE_KOKKOS_ENABLED
+
+} // namespace vt::collective::reduce::allreduce
+#endif /*INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_RABENSEIFNER_MSG_H*/
diff --git a/src/vt/collective/reduce/allreduce/recursive_doubling.cc b/src/vt/collective/reduce/allreduce/recursive_doubling.cc
new file mode 100644
index 0000000000..22099f86e7
--- /dev/null
+++ b/src/vt/collective/reduce/allreduce/recursive_doubling.cc
@@ -0,0 +1,120 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                            recursive_doubling.cc
+//                       DARMA/vt => Virtual Transport
+//
+// Copyright 2019-2024 National Technology & Engineering Solutions of Sandia, LLC
+// (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact darma@sandia.gov
+//
+// *****************************************************************************
+//@HEADER
+*/
+
+#include "vt/collective/reduce/allreduce/recursive_doubling.h"
+#include "vt/collective/reduce/allreduce/helpers.h"
+#include "vt/group/group_manager.h"
+
+namespace vt::collective::reduce::allreduce {
+
+RecursiveDoubling::RecursiveDoubling(
+  detail::StrongVrtProxy proxy, detail::StrongGroup group, size_t num_elems)
+  : info_({ComponentT::VrtColl, proxy.get()}),
+    local_num_elems_(num_elems),
+    nodes_(theGroup()->GetGroupNodes(group.get())),
+    num_nodes_(nodes_.size()),
+    this_node_(theContext()->getNode()),
+    num_steps_(static_cast<uint32_t>(std::log2(num_nodes_))),
+    nprocs_pof2_(1 << num_steps_),
+    nprocs_rem_(num_nodes_ - nprocs_pof2_) {
+  auto const is_default_group = theGroup()->isGroupDefault(group.get());
+  if (not is_default_group) {
+    auto it = std::find(nodes_.begin(), nodes_.end(), theContext()->getNode());
+    vtAssert(it != nodes_.end(), fmt::format("This node was not found in group nodes! Size={}", nodes_.size()));
+
+    this_node_ = it - nodes_.begin();
+  }
+
+  is_even_ = this_node_ % 2 == 0;
+  is_part_of_adjustment_group_ = this_node_ < (2 * nprocs_rem_);
+  initializeVrtNode();
+
+  vt_debug_print(
+    terse, allreduce,
+    "RecursiveDoubling (this={}): proxy={:x} local_num_elems={}\n",
+    print_ptr(this), proxy.get(), local_num_elems_);
+}
+
+RecursiveDoubling::RecursiveDoubling(detail::StrongObjGroup objgroup)
+  : info_({ComponentT::ObjGroup, objgroup.get()}),
+    num_nodes_(theContext()->getNumNodes()),
+    this_node_(vt::theContext()->getNode()),
+    is_even_(this_node_ % 2 == 0),
+    num_steps_(static_cast<int32_t>(log2(num_nodes_))),
+    nprocs_pof2_(1 << num_steps_),
+    nprocs_rem_(num_nodes_ - nprocs_pof2_),
+    is_part_of_adjustment_group_(this_node_ < (2 * nprocs_rem_)) {
+  nodes_.resize(num_nodes_);
+  for (NodeType i = 0; i < theContext()->getNumNodes(); ++i) {
+    nodes_[i] = i;
+  }
+
+  initializeVrtNode();
+}
+
+RecursiveDoubling::RecursiveDoubling(detail::StrongGroup group)
+  : info_({ComponentT::Group, group.get()}),
+    nodes_(theGroup()->GetGroupNodes(group.get())),
+    num_nodes_(nodes_.size()),
+    this_node_(vt::theContext()->getNode()),
+    is_even_(this_node_ % 2 == 0),
+    num_steps_(static_cast<int32_t>(log2(num_nodes_))),
+    nprocs_pof2_(1 << num_steps_),
+    nprocs_rem_(num_nodes_ - nprocs_pof2_),
+    is_part_of_adjustment_group_(this_node_ < (2 * nprocs_rem_)) {
+  initializeVrtNode();
+}
+
+void RecursiveDoubling::initializeVrtNode() {
+  if (is_part_of_adjustment_group_) {
+    if (is_even_) {
+      vrt_node_ = this_node_ / 2;
+    } else {
+      vrt_node_ = -1;
+    }
+  } else {
+    vrt_node_ = this_node_ - nprocs_rem_;
+  }
+}
+
+} // namespace vt::collective::reduce::allreduce
diff --git a/src/vt/collective/reduce/allreduce/recursive_doubling.h b/src/vt/collective/reduce/allreduce/recursive_doubling.h
new file mode 100644
index 0000000000..49f348c7be
--- /dev/null
+++ b/src/vt/collective/reduce/allreduce/recursive_doubling.h
@@ -0,0 +1,280 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                             recursive_doubling.h
+//                       DARMA/vt => Virtual Transport
+//
+// Copyright 2019-2024 National Technology & Engineering Solutions of Sandia, LLC
+// (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact darma@sandia.gov
+//
+// *****************************************************************************
+//@HEADER
+*/
+
+#if !defined INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_RECURSIVE_DOUBLING_H
+#define INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_RECURSIVE_DOUBLING_H
+
+#include "vt/objgroup/proxy/proxy_objgroup.h"
+#include "type.h"
+#include "vt/configs/types/types_type.h"
+#include "vt/collective/reduce/allreduce/recursive_doubling_msg.h"
+
+namespace vt::collective::reduce::allreduce {
+
+/**
+ * \brief Class implementing the Recursive Doubling algorithm for allreduce operation.
+ *
+ * This class provides an implementation of the Recursive Doubling algorithm for the
+ * allreduce operation. It is parameterized by the data type to be reduced, the reduction
+ * operation, the object type, and the final handler.
+ */
+
+struct RecursiveDoubling {
+
+  /**
+   * \brief Constructor for Collection
+   *
+   * \param proxy Collection proxy
+   * \param group GroupID (for given collection)
+   * \param num_elems Number of local collection elements
+   */
+  RecursiveDoubling(detail::StrongVrtProxy proxy, detail::StrongGroup group, size_t num_elems);
+
+  /**
+   * \brief Constructor for ObjGroup
+   *
+   * \param objgroup ObjGroupProxy
+   */
+  RecursiveDoubling(detail::StrongObjGroup objgroup);
+
+  /**
+   * \brief Constructor for Group
+   *
+   * \param group GroupID
+   */
+  RecursiveDoubling(detail::StrongGroup group);
+
+  /**
+   * \brief Initialize vrt_node_ variable
+   */
+  void initializeVrtNode();
+
+  /**
+   * \brief Execute the final handler callback with the reduced result.
+   *
+   * \param id Allreduce ID
+   */
+  template <typename DataT>
+  void executeFinalHan(size_t id);
+
+  /**
+   * \brief Set final handler that will be executed with allreduce result
+   *
+   * \param fin Callback to be executed
+   * \param id Allreduce ID
+   */
+  template <typename DataT, typename CallbackType>
+  void setFinalHandler(const CallbackType& fin, size_t id);
+
+  template <typename DataT, template <typename Arg> class Op, typename... Args>
+  void storeData(size_t id, Args&&... args);
+
+  /**
+   * \brief Performs local reduce, and once the local one is done it starts up the global allreduce
+   *
+   * \param id Allreduce ID
+   * \param args Data to be allreduced
+   */
+  template <typename DataT, template <typename Arg> class Op>
+  void run(size_t id);
+
+  /**
+   * \brief Start the allreduce operation.
+   *
+   * \param id Allreduce ID
+   */
+  template <typename DataT, template <typename Arg> class Op>
+  void allreduce(size_t id);
+
+  /**
+   * \brief Initialize the RecursiveDoubling object.
+   *
+   * \param id Allreduce ID
+   * \param args Additional arguments for data initialization.
+   */
+  template <typename DataT, typename ...Args>
+  void initialize(size_t id, Args&&... data);
+
+  /**
+   * \brief Initialize the internal state of allreduce algorithm.
+   *
+   * \param id Allreduce ID
+   */
+  template <typename DataT>
+  void initializeState(size_t id);
+
+  /**
+   * \brief Adjust for power of two nodes.
+   *
+   * \param id Allreduce ID
+   */
+  template <typename DataT, template <typename Arg> class Op>
+  void adjustForPowerOfTwo(size_t id);
+
+  /**
+   * \brief Handler for adjusting for power of two nodes.
+   *
+   * \param msg Pointer to the message.
+   */
+  template <typename DataT, template <typename Arg> class Op>
+  static void adjustForPowerOfTwoHandler(RecursiveDoublingMsg<DataT>* msg);
+
+  template <typename DataT, template <typename Arg> class Op>
+  void adjustForPowerOfTwoHan(RecursiveDoublingMsg<DataT>* msg);
+
+  /**
+   * \brief Check if the allreduce operation is done.
+   *
+   * \param id Allreduce ID
+   * \return True if the operation is done, otherwise false.
+   */
+  template <typename DataT>
+  bool isDone(size_t id);
+
+  /**
+   * \brief Check if the current state is valid for allreduce.
+   *
+   * \param id Allreduce ID
+   * \return True if the state is valid, otherwise false.
+   */
+  template <typename DataT>
+  bool isValid(size_t id);
+
+  /**
+   * \brief Check if all messages are received for the current step.
+   *
+   * \param id Allreduce ID
+   * \return True if all messages are received, otherwise false.
+   */
+  template <typename DataT>
+  bool allMessagesReceived(size_t id);
+
+  /**
+   * \brief Check if the object is ready for the next step of allreduce.
+   *
+   * \param id Allreduce ID
+   * \return True if ready, otherwise false.
+   */
+  template <typename DataT>
+  bool isReady(size_t id);
+
+  /**
+   * \brief Perform the next step of the allreduce operation.
+   *
+   * \param id Allreduce ID
+   */
+  template <typename DataT, template <typename Arg> class Op>
+  void reduceIter(size_t id);
+
+  /**
+   * \brief Try to reduce the message at the specified step.
+   *
+   * \param id Allreduce ID
+   * \param step The step at which to try reduction.
+   */
+  template <typename DataT, template <typename Arg> class Op>
+  void tryReduce(size_t id, int32_t step);
+
+  /**
+   * \brief Handler for the reduce iteration.
+   *
+   * \param msg Pointer to the message.
+   */
+  template <typename DataT, template <typename Arg> class Op>
+  static void reduceIterHandler(RecursiveDoublingMsg<DataT>* msg);
+
+  template <typename DataT, template <typename Arg> class Op>
+  void reduceIterHan(RecursiveDoublingMsg<DataT>* msg);
+
+  /**
+   * \brief Send data to excluded nodes for finalization.
+   *
+   * \param id Allreduce ID
+   */
+  template <typename DataT>
+  void sendToExcludedNodes(size_t id);
+
+  /**
+   * \brief Handler for sending data to excluded nodes.
+   *
+   * \param msg Pointer to the message.
+   */
+  template <typename DataT>
+  static void sendToExcludedNodesHandler(RecursiveDoublingMsg<DataT>* msg);
+
+  template <typename DataT>
+  void sendToExcludedNodesHan(RecursiveDoublingMsg<DataT>* msg);
+
+  /**
+   * \brief Perform the final part of the allreduce operation.
+   *
+   * \param id Allreduce ID
+   */
+  template <typename DataT>
+  void finalPart(size_t id);
+
+private:
+
+  ComponentInfo info_ = {};
+
+  size_t local_num_elems_ = 1;
+
+  std::vector<NodeType> nodes_ = {};
+  NodeType num_nodes_ = {};
+  NodeType this_node_ = {};
+
+  bool is_even_ = false;
+  int32_t num_steps_ = {};
+  int32_t nprocs_pof2_ = {};
+  int32_t nprocs_rem_ = {};
+
+  NodeType vrt_node_ = {};
+  bool is_part_of_adjustment_group_ = false;
+  static inline ReducerType type_ = ReducerType::RecursiveDoubling;
+};
+
+} // namespace vt::collective::reduce::allreduce
+
+#include "recursive_doubling.impl.h"
+
+#endif /*INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_RECURSIVE_DOUBLING_H*/
diff --git a/src/vt/collective/reduce/allreduce/recursive_doubling.impl.h b/src/vt/collective/reduce/allreduce/recursive_doubling.impl.h
new file mode 100644
index 0000000000..307ef92b46
--- /dev/null
+++ b/src/vt/collective/reduce/allreduce/recursive_doubling.impl.h
@@ -0,0 +1,412 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                          recursive_doubling.impl.h
+//                       DARMA/vt => Virtual Transport
+//
+// Copyright 2019-2024 National Technology & Engineering Solutions of Sandia, LLC
+// (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact darma@sandia.gov
+//
+// *****************************************************************************
+//@HEADER
+*/
+
+#if !defined INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_RECURSIVE_DOUBLING_IMPL_H
+#define INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_RECURSIVE_DOUBLING_IMPL_H
+
+#include "vt/config.h"
+#include "vt/context/context.h"
+#include "vt/collective/reduce/allreduce/recursive_doubling.h"
+#include "vt/collective/reduce/allreduce/state_holder.h"
+#include "vt/collective/reduce/allreduce/allreduce_holder.h"
+#include "vt/collective/reduce/allreduce/data_handler.h"
+#include "vt/collective/reduce/allreduce/type.h"
+#include "vt/messaging/active.h"
+#include "vt/topos/location/location.impl.h"
+
+namespace vt::collective::reduce::allreduce {
+
+template <typename DataT, typename CallbackType>
+void RecursiveDoubling::setFinalHandler(const CallbackType& fin, size_t id) {
+  auto& state = getState<RecursiveDoublingT, DataT>(info_, id);
+  state.final_handler_ = fin;
+}
+
+template <typename DataT, template <typename Arg> class Op, typename... Args>
+void RecursiveDoubling::storeData(size_t id, Args&&... data) {
+  auto& state = getState<RecursiveDoublingT, DataT>(info_, id);
+
+  vt_debug_print(
+    terse, allreduce,
+    "RecursiveDoubling::storeData (this={}): local_col_wait_count_={} ID={} "
+    "initialized={}\n",
+    print_ptr(this), state.local_col_wait_count_, id, state.initialized_);
+
+  if (not state.value_assigned_) {
+    initialize<DataT>(id, std::forward<Args>(data)...);
+  } else {
+    Op<DataT>()(state.val_, std::forward<Args>(data)...);
+  }
+
+  state.local_col_wait_count_++;
+}
+
+template <typename DataT, template <typename Arg> class Op>
+void RecursiveDoubling::run(size_t id) {
+  auto& state = getState<RecursiveDoublingT, DataT>(info_, id);
+  auto const is_ready = state.local_col_wait_count_ == local_num_elems_;
+
+  if (is_ready) {
+    // Execute early in case we're the only node
+    if (num_nodes_ < 2) {
+      executeFinalHan<DataT>(id);
+    } else {
+      allreduce<DataT, Op>(id);
+    }
+  }
+}
+
+template <typename DataT, typename... Args>
+void RecursiveDoubling::initialize(size_t id, Args&&... data) {
+  using DataType = DataHandler<DataT>;
+  auto& state = getState<RecursiveDoublingT, DataT>(info_, id);
+
+  if (not state.initialized_) {
+    initializeState<DataT>(id);
+  }
+
+  state.val_ = DataT{std::forward<Args>(data)...};
+  state.value_assigned_ = true;
+  state.active_ = true;
+
+  vt_debug_print(
+    terse, allreduce, "RecursiveDoubling Initialize: size {} ID {}\n",
+    DataType::size(state.val_), id);
+}
+
+template <typename DataT>
+void RecursiveDoubling::initializeState(size_t id) {
+  auto& state = getState<RecursiveDoublingT, DataT>(info_, id);
+
+  vt_debug_print(
+    terse, allreduce, "RecursiveDoubling initializing state for ID = {}\n", id);
+
+  state.messages_.resize(num_steps_, nullptr);
+  state.steps_recv_.resize(num_steps_, false);
+  state.steps_reduced_.resize(num_steps_, false);
+
+  state.completed_ = false;
+  state.step_ = 0;
+  state.mask_ = 1;
+  state.finished_adjustment_part_ = not is_part_of_adjustment_group_;
+  state.initialized_ = true;
+}
+
+template <typename DataT, template <typename Arg> class Op>
+void RecursiveDoubling::allreduce(size_t id) {
+  if (is_part_of_adjustment_group_) {
+    adjustForPowerOfTwo<DataT, Op>(id);
+  } else {
+    reduceIter<DataT, Op>(id);
+  }
+}
+
+template <typename DataT, template <typename Arg> class Op>
+void RecursiveDoubling::adjustForPowerOfTwo(size_t id) {
+  auto& state = getState<RecursiveDoublingT, DataT>(info_, id);
+  if (is_part_of_adjustment_group_ and not is_even_) {
+    vt_debug_print(
+      terse, allreduce, "RecursiveDoubling AdjustInitial (To {}): ID = {}  \n",
+      this_node_, this_node_ - 1, id);
+
+    auto const partner = Node{static_cast<NodeType>(this_node_ - NodeType{1})};
+    theMsg()
+      ->template sendMsg<
+        RecursiveDoubling::template adjustForPowerOfTwoHandler<DataT, Op>>(
+        partner.get(),
+        vt::makeMessage<RecursiveDoublingMsg<DataT>>(info_, state.val_, id));
+  } else if (state.adjust_message_ != nullptr) {
+    // We have pending reduce message
+    adjustForPowerOfTwoHan<DataT, Op>(state.adjust_message_.get());
+  }
+}
+
+template <typename DataT, template <typename Arg> class Op>
+/*static*/ void RecursiveDoubling::adjustForPowerOfTwoHandler(
+  RecursiveDoublingMsg<DataT>* msg) {
+  auto* reducer = getAllreducer<RecursiveDoublingT>(msg->info_);
+
+  if(reducer){
+    reducer->template adjustForPowerOfTwoHan<DataT, Op>(msg);
+  }else{
+    auto& state = getState<RecursiveDoublingT, DataT>(msg->info_, msg->id_);
+    state.adjust_message_ = promoteMsg(msg);
+  }
+}
+
+template <typename DataT, template <typename Arg> class Op>
+void RecursiveDoubling::adjustForPowerOfTwoHan(
+  RecursiveDoublingMsg<DataT>* msg) {
+  auto& state = getState<RecursiveDoublingT, DataT>(info_, msg->id_);
+  if (not state.value_assigned_) {
+    if (not state.initialized_) {
+      initializeState<DataT>(msg->id_);
+    }
+    state.adjust_message_ = promoteMsg(msg);
+
+    return;
+  }
+
+  Op<DataT>()(state.val_, *(msg->val_));
+
+  state.finished_adjustment_part_ = true;
+
+  reduceIter<DataT, Op>(msg->id_);
+}
+
+template <typename DataT>
+bool RecursiveDoubling::isDone(size_t id) {
+  auto& state = getState<RecursiveDoublingT, DataT>(info_, id);
+  return (state.step_ == num_steps_) and allMessagesReceived<DataT>(id);
+}
+
+template <typename DataT>
+bool RecursiveDoubling::isValid(size_t id) {
+  auto& state = getState<RecursiveDoublingT, DataT>(info_, id);
+  return (vrt_node_ != -1) and (state.step_ < num_steps_);
+}
+
+template <typename DataT>
+bool RecursiveDoubling::allMessagesReceived(size_t id) {
+  auto& state = getState<RecursiveDoublingT, DataT>(info_, id);
+  return std::all_of(
+    state.steps_recv_.cbegin(), state.steps_recv_.cbegin() + state.step_,
+    [](const auto val) { return val; });
+}
+
+template <typename DataT>
+bool RecursiveDoubling::isReady(size_t id) {
+  auto& state = getState<RecursiveDoublingT, DataT>(info_, id);
+  return ((is_part_of_adjustment_group_ and state.finished_adjustment_part_) and
+          state.step_ == 0) or
+    allMessagesReceived<DataT>(id);
+}
+
+template <typename DataT, template <typename Arg> class Op>
+void RecursiveDoubling::reduceIter(size_t id) {
+  // Ensure we have received all necessary messages
+  if (not isReady<DataT>(id)) {
+    return;
+  }
+
+  auto& state = getState<RecursiveDoublingT, DataT>(info_, id);
+  auto vdest = vrt_node_ ^ state.mask_;
+  auto dest = (vdest < nprocs_rem_) ? vdest * 2 : vdest + nprocs_rem_;
+  vt_debug_print(
+    terse, allreduce,
+    "RecursiveDoubling Part2 (Send step {}): To Node {} ID = {} \n",
+    state.step_, dest, id);
+
+  auto const partner = static_cast<NodeType>(dest);
+  theMsg()
+    ->sendMsg<
+      reduceIterHandler<DataT, Op>>(
+      partner,
+      vt::makeMessage<RecursiveDoublingMsg<DataT>>(
+        info_, state.val_, id, state.step_));
+
+  state.mask_ <<= 1;
+  state.step_++;
+
+  tryReduce<DataT, Op>(id, state.step_ - 1);
+
+  if (isDone<DataT>(id)) {
+    finalPart<DataT>(id);
+  } else if (isReady<DataT>(id)) {
+    reduceIter<DataT, Op>(id);
+  }
+}
+
+template <typename DataT, template <typename Arg> class Op>
+void RecursiveDoubling::tryReduce(size_t id, int32_t step) {
+  auto& state = getState<RecursiveDoublingT, DataT>(info_, id);
+  auto const all_msgs_received = std::all_of(
+    state.steps_reduced_.cbegin(), state.steps_reduced_.cbegin() + step,
+    [](const auto val) { return val; });
+
+  vt_debug_print(
+    terse, allreduce,
+    "RecursiveDoubling Part2 (Reduce step {}): state.step_ = {} "
+    "state.steps_reduced_[step] = {} state.steps_recv_[step] = {} "
+    "all_msgs_received = {} ID = {} \n",
+    step, state.step_, static_cast<bool>(state.steps_reduced_[step]),
+    static_cast<bool>(state.steps_recv_[step]), all_msgs_received, id);
+
+  if (
+    (step < state.step_) and not state.steps_reduced_[step] and
+    state.steps_recv_[step] and all_msgs_received) {
+    Op<DataT>()(state.val_, *(state.messages_.at(step)->val_));
+
+    state.steps_reduced_[step] = true;
+  }
+}
+
+template <typename DataT, template <typename Arg> class Op>
+/*static*/ void
+RecursiveDoubling::reduceIterHandler(RecursiveDoublingMsg<DataT>* msg) {
+  auto* reducer = getAllreducer<RecursiveDoublingT>(msg->info_);
+
+  vt_debug_print(
+    terse, allreduce,
+    "RecursiveDoubling::reduceIterHandler reducer={} ID={} \n",
+    (reducer != nullptr), msg->id_
+  );
+
+  if(reducer){
+    reducer->template reduceIterHan<DataT, Op>(msg);
+  }else{
+    auto& state = getState<RecursiveDoublingT, DataT>(msg->info_, msg->id_);
+    if(state.messages_.size() < static_cast<size_t>(msg->step_ + 1)){
+      state.messages_.resize(msg->step_ + 1, nullptr);
+    }
+    state.messages_.at(msg->step_) = promoteMsg(msg);
+
+    if(state.steps_recv_.size() < static_cast<size_t>(msg->step_ + 1)){
+      state.steps_recv_.resize(msg->step_ + 1, false);
+    }
+    state.steps_recv_[msg->step_] = true;
+  }
+}
+
+template <typename DataT, template <typename Arg> class Op>
+void RecursiveDoubling::reduceIterHan(RecursiveDoublingMsg<DataT>* msg) {
+  auto& state = getState<RecursiveDoublingT, DataT>(info_, msg->id_);
+
+  if (not state.value_assigned_) {
+    if (not state.initialized_) {
+      initializeState<DataT>(msg->id_);
+    }
+    state.messages_.at(msg->step_) = promoteMsg(msg);
+    state.steps_recv_[msg->step_] = true;
+
+    return;
+  }
+
+  state.messages_.at(msg->step_) = promoteMsg(msg);
+  state.steps_recv_[msg->step_] = true;
+
+  vt_debug_print(
+    terse, allreduce,
+    "RecursiveDoubling Part2 (Recv step {}): finished_adjustment_part_ = {} "
+    "mask_= {} nprocs_pof2_ = {} "
+    "from {} ID = {}\n",
+    msg->step_, state.finished_adjustment_part_, state.mask_, nprocs_pof2_,
+    theContext()->getFromNodeCurrentTask(), msg->id_);
+
+  // Special case when we receive step 2 message before step 1 is done on this node
+  if (not state.finished_adjustment_part_) {
+    return;
+  }
+
+  tryReduce<DataT, Op>(msg->id_, msg->step_);
+
+  if ((state.mask_ < nprocs_pof2_) and isReady<DataT>(msg->id_)) {
+    reduceIter<DataT, Op>(msg->id_);
+
+  } else if (isDone<DataT>(msg->id_)) {
+    finalPart<DataT>(msg->id_);
+  }
+}
+
+template <typename DataT>
+void RecursiveDoubling::sendToExcludedNodes(size_t id) {
+  if (is_part_of_adjustment_group_ and is_even_) {
+    vt_debug_print(
+      terse, allreduce, "RecursiveDoubling Part3: Sending to Node {} ID = {}\n",
+      this_node_ + 1, id);
+
+    auto& state = getState<RecursiveDoublingT, DataT>(info_, id);
+    auto const partner = static_cast<NodeType>(this_node_ + 1);
+    theMsg()
+      ->sendMsg<
+        sendToExcludedNodesHandler<DataT>>(
+        partner,
+        vt::makeMessage<RecursiveDoublingMsg<DataT>>(info_, state.val_, id));
+  }
+}
+
+template <typename DataT>
+/*static*/ void RecursiveDoubling::sendToExcludedNodesHandler(
+  RecursiveDoublingMsg<DataT>* msg) {
+  getAllreducer<RecursiveDoublingT>(msg->info_)
+    ->template sendToExcludedNodesHan<DataT>(msg);
+}
+
+template <typename DataT>
+void RecursiveDoubling::sendToExcludedNodesHan(
+  RecursiveDoublingMsg<DataT>* msg) {
+  auto& state = getState<RecursiveDoublingT, DataT>(info_, msg->id_);
+  state.val_ = *msg->val_;
+  executeFinalHan<DataT>(msg->id_);
+}
+
+template <typename DataT>
+void RecursiveDoubling::finalPart(size_t id) {
+  auto& state = getState<RecursiveDoublingT, DataT>(info_, id);
+  if (state.completed_) {
+    return;
+  }
+
+  if (nprocs_rem_) {
+    sendToExcludedNodes<DataT>(id);
+  }
+
+  executeFinalHan<DataT>(id);
+}
+
+template <typename DataT>
+void RecursiveDoubling::executeFinalHan(size_t id) {
+  auto& state = getState<RecursiveDoublingT, DataT>(info_, id);
+  vt_debug_print(
+    terse, allreduce, "RecursiveDoubling executing final handler ID = {}\n",
+    id);
+
+  state.final_handler_.send(std::move(state.val_));
+
+  state.completed_ = true;
+  cleanupState(info_, id);
+}
+
+} // namespace vt::collective::reduce::allreduce
+
+#endif /*INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_RECURSIVE_DOUBLING_IMPL_H*/
diff --git a/src/vt/collective/reduce/allreduce/recursive_doubling_msg.h b/src/vt/collective/reduce/allreduce/recursive_doubling_msg.h
new file mode 100644
index 0000000000..97518b5962
--- /dev/null
+++ b/src/vt/collective/reduce/allreduce/recursive_doubling_msg.h
@@ -0,0 +1,96 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                           recursive_doubling_msg.h
+//                       DARMA/vt => Virtual Transport
+//
+// Copyright 2019-2024 National Technology & Engineering Solutions of Sandia, LLC
+// (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact darma@sandia.gov
+//
+// *****************************************************************************
+//@HEADER
+*/
+
+#if !defined INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_RECURSIVE_DOUBLING_MSG_H
+#define INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_RECURSIVE_DOUBLING_MSG_H
+
+#include "vt/messaging/active.h"
+#include "type.h"
+namespace vt::collective::reduce::allreduce {
+
+template <typename DataT>
+struct RecursiveDoublingMsg : Message {
+  using MessageParentType = vt::Message;
+  vt_msg_serialize_required();
+
+  RecursiveDoublingMsg() = default;
+  RecursiveDoublingMsg(RecursiveDoublingMsg const&) = default;
+  RecursiveDoublingMsg(RecursiveDoublingMsg&&) = default;
+  ~RecursiveDoublingMsg() {
+    if (owning_) {
+      delete val_;
+    }
+  }
+
+  RecursiveDoublingMsg(ComponentInfo info, DataT const& in_val, size_t id, int step = 0)
+    : MessageParentType(),
+      val_(&in_val),
+      id_(id),
+      step_(step),
+      info_(info) { }
+
+  template <typename SerializeT>
+  void serialize(SerializeT& s) {
+    MessageParentType::serialize(s);
+
+    if (s.isUnpacking()) {
+      owning_ = true;
+      val_ = new DataT();
+    }
+
+    s | *val_;
+    s | id_;
+    s | step_;
+    s | info_;
+  }
+
+  const DataT* val_ = {};
+  size_t id_ = {};
+  int32_t step_ = {};
+  bool owning_ = false;
+  ComponentInfo info_ = {};
+};
+
+} // namespace vt::collective::reduce::allreduce
+
+#endif /*INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_RECURSIVE_DOUBLING_MSG_H*/
diff --git a/src/vt/collective/reduce/allreduce/state.h b/src/vt/collective/reduce/allreduce/state.h
new file mode 100644
index 0000000000..3af1de1e7a
--- /dev/null
+++ b/src/vt/collective/reduce/allreduce/state.h
@@ -0,0 +1,141 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                                   state.h
+//                       DARMA/vt => Virtual Transport
+//
+// Copyright 2019-2024 National Technology & Engineering Solutions of Sandia, LLC
+// (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact darma@sandia.gov
+//
+// *****************************************************************************
+//@HEADER
+*/
+
+#if !defined INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_STATE_H
+#define INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_STATE_H
+
+#include "vt/collective/reduce/allreduce/rabenseifner_msg.h"
+#include "vt/collective/reduce/allreduce/recursive_doubling_msg.h"
+
+namespace vt::collective::reduce::allreduce {
+
+struct StateBase {
+  virtual ~StateBase() = default;
+  size_t size_ = {};
+
+  uint32_t local_col_wait_count_ = 0;
+  bool finished_adjustment_part_ = false;
+
+  int32_t mask_ = 1;
+  int32_t step_ = 0;
+  bool initialized_ = false;
+  bool completed_ = false;
+  bool active_ = false;
+};
+
+struct RabenseifnerBase : StateBase {
+  ~RabenseifnerBase() override = default;
+  // Scatter
+  int32_t scatter_mask_ = 1;
+  int32_t scatter_step_ = 0;
+  int32_t scatter_num_recv_ = 0;
+  std::vector<bool> scatter_steps_recv_ = {};
+  std::vector<bool> scatter_steps_reduced_ = {};
+
+  bool finished_scatter_part_ = false;
+
+  // Gather
+  int32_t gather_step_ = 0;
+  int32_t gather_mask_ = 1;
+  int32_t gather_num_recv_ = 0;
+  std::vector<bool> gather_steps_recv_ = {};
+  std::vector<bool> gather_steps_reduced_ = {};
+
+  std::vector<uint32_t> r_index_ = {};
+  std::vector<uint32_t> r_count_ = {};
+  std::vector<uint32_t> s_index_ = {};
+  std::vector<uint32_t> s_count_ = {};
+};
+
+template <typename DataT>
+struct RecursiveDoublingState : StateBase {
+  ~RecursiveDoublingState() override = default;
+
+  DataT val_ = {};
+  bool value_assigned_ = false;
+  MsgSharedPtr<RecursiveDoublingMsg<DataT>> adjust_message_ = nullptr;
+
+  std::vector<bool> steps_recv_ = {};
+  std::vector<bool> steps_reduced_ = {};
+  std::vector<MsgSharedPtr<RecursiveDoublingMsg<DataT>>> messages_ = {};
+  vt::pipe::callback::cbunion::CallbackTyped<DataT> final_handler_ = {};
+};
+
+template <typename Scalar, typename DataT>
+struct RabenseifnerState : RabenseifnerBase {
+  using RabenseifnerMsgT = MsgSharedPtr<RabenseifnerMsg<Scalar, DataT>>;
+
+  ~RabenseifnerState() override = default;
+
+  std::vector<Scalar> val_ = {};
+
+  RabenseifnerMsgT left_adjust_message_ = nullptr;
+  RabenseifnerMsgT right_adjust_message_ = nullptr;
+  std::vector<RabenseifnerMsgT> scatter_messages_ = {};
+  std::vector<RabenseifnerMsgT> gather_messages_ = {};
+
+  vt::pipe::callback::cbunion::CallbackTyped<DataT> final_handler_ = {};
+};
+
+#if MAGISTRATE_KOKKOS_ENABLED
+template <typename Scalar, typename... Properties>
+struct RabenseifnerState<Scalar, Kokkos::View<Scalar*, Properties...>>
+  : RabenseifnerBase {
+  using DataT = Kokkos::View<Scalar*, Properties...>;
+  using RabenseifnerMsgT = MsgSharedPtr<RabenseifnerMsg<Scalar, DataT>>;
+  ~RabenseifnerState() override = default;
+
+  DataT val_ = {};
+
+  RabenseifnerMsgT left_adjust_message_ = nullptr;
+  RabenseifnerMsgT right_adjust_message_ = nullptr;
+  std::vector<RabenseifnerMsgT> scatter_messages_ = {};
+  std::vector<RabenseifnerMsgT> gather_messages_ = {};
+
+  vt::pipe::callback::cbunion::CallbackTyped<DataT> final_handler_ = {};
+};
+#endif //MAGISTRATE_KOKKOS_ENABLED
+
+} // namespace vt::collective::reduce::allreduce
+
+#endif /*INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_STATE_H*/
diff --git a/src/vt/collective/reduce/allreduce/state_holder.cc b/src/vt/collective/reduce/allreduce/state_holder.cc
new file mode 100644
index 0000000000..0c3c81cb2e
--- /dev/null
+++ b/src/vt/collective/reduce/allreduce/state_holder.cc
@@ -0,0 +1,143 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                               state_holder.cc
+//                       DARMA/vt => Virtual Transport
+//
+// Copyright 2019-2024 National Technology & Engineering Solutions of Sandia, LLC
+// (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact darma@sandia.gov
+//
+// *****************************************************************************
+//@HEADER
+*/
+
+#include "vt/config.h"
+#include "state_holder.h"
+#include "vt/configs/error/hard_error.h"
+#include "vt/configs/error/config_assert.h"
+
+namespace vt::collective::reduce::allreduce {
+
+size_t
+getNextIdImpl(StateHolder::StatesVec& states, size_t idx) {
+  size_t id = u64empty;
+
+  vt_debug_print(
+    terse, allreduce, "getNextIdImpl idx={} size={} \n", idx, states.size());
+
+  for (; idx < states.size(); ++idx) {
+    auto& state = states.at(idx);
+    if (not state or not state->active_) {
+      id = idx;
+      break;
+    }
+  }
+
+  if (id == u64empty) {
+    id = states.size();
+  }
+
+
+  return id;
+}
+
+size_t StateHolder::getNextID(detail::StrongVrtProxy proxy) {
+  auto& [idx, states] = active_coll_states_[proxy.get()];
+
+  auto current_idx =  getNextIdImpl(states, idx);
+  idx = current_idx + 1;
+
+  return current_idx;
+}
+
+size_t StateHolder::getNextID(detail::StrongObjGroup proxy) {
+  auto& [idx, states] = active_obj_states_[proxy.get()];
+
+  auto current_idx = getNextIdImpl(states, idx);
+  idx = current_idx + 1;
+
+  return current_idx;
+}
+
+size_t StateHolder::getNextID(detail::StrongGroup group) {
+  auto& [idx, states] = active_grp_states_[group.get()];
+
+  auto current_idx = getNextIdImpl(states, idx);
+
+  idx = current_idx + 1;
+  return current_idx;
+}
+
+static inline void
+clearSingleImpl(StateHolder::StatesVec& states, size_t idx) {
+  auto const num_states = states.size();
+  vtAssert(
+    num_states > idx,
+    fmt::format(
+      "Attempting to access state {} with total numer of states {}!", idx,
+      num_states));
+
+  states.at(idx).reset();
+}
+
+void StateHolder::clearSingle(detail::StrongVrtProxy proxy, size_t idx) {
+  auto& [_, states] = active_coll_states_[proxy.get()];
+
+  clearSingleImpl(states, idx);
+}
+
+void StateHolder::clearSingle(detail::StrongObjGroup proxy, size_t idx) {
+  auto& [_, states] = active_obj_states_[proxy.get()];
+
+  clearSingleImpl(states, idx);
+}
+
+void StateHolder::clearSingle(detail::StrongGroup group, size_t idx) {
+  auto& [_, states] = active_grp_states_[group.get()];
+
+  clearSingleImpl(states, idx);
+}
+
+void StateHolder::clearAll(detail::StrongVrtProxy proxy) {
+  active_coll_states_.erase(proxy.get());
+}
+
+void StateHolder::clearAll(detail::StrongObjGroup proxy) {
+  active_obj_states_.erase(proxy.get());
+}
+
+void StateHolder::clearAll(detail::StrongGroup group) {
+  active_grp_states_.erase(group.get());
+}
+
+} // namespace vt::collective::reduce::allreduce
diff --git a/src/vt/collective/reduce/allreduce/state_holder.h b/src/vt/collective/reduce/allreduce/state_holder.h
new file mode 100644
index 0000000000..93055403f3
--- /dev/null
+++ b/src/vt/collective/reduce/allreduce/state_holder.h
@@ -0,0 +1,128 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                                state_holder.h
+//                       DARMA/vt => Virtual Transport
+//
+// Copyright 2019-2024 National Technology & Engineering Solutions of Sandia, LLC
+// (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact darma@sandia.gov
+//
+// *****************************************************************************
+//@HEADER
+*/
+
+#if !defined INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_STATE_HOLDER_H
+#define INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_STATE_HOLDER_H
+
+#include "vt/collective/reduce/allreduce/data_handler.h"
+#include "vt/collective/reduce/allreduce/type.h"
+#include "vt/collective/reduce/scoping/strong_types.h"
+#include "vt/configs/types/types_type.h"
+#include "vt/collective/reduce/allreduce/state.h"
+
+#include <memory>
+#include <unordered_map>
+
+namespace vt::collective::reduce::allreduce {
+
+struct StateHolder {
+  using StatesVec = std::vector<std::unique_ptr<StateBase>>;
+  using StatesInfo = std::pair<size_t, StatesVec>;
+
+  template <
+    typename ReducerT, typename DataT,
+    typename Scalar = typename DataHandler<DataT>::Scalar>
+  static decltype(auto) getState(detail::StrongVrtProxy proxy, size_t idx);
+
+  template <
+    typename ReducerT, typename DataT,
+    typename Scalar = typename DataHandler<DataT>::Scalar>
+  static decltype(auto) getState(detail::StrongObjGroup proxy, size_t idx);
+
+  template <
+    typename ReducerT, typename DataT,
+    typename Scalar = typename DataHandler<DataT>::Scalar>
+  static decltype(auto) getState(detail::StrongGroup proxy, size_t idx);
+
+  static size_t getNextID(detail::StrongVrtProxy proxy);
+  static size_t getNextID(detail::StrongObjGroup proxy);
+  static size_t getNextID(detail::StrongGroup group);
+
+  static void clearSingle(detail::StrongVrtProxy proxy, size_t idx);
+  static void clearSingle(detail::StrongObjGroup proxy, size_t idx);
+  static void clearSingle(detail::StrongGroup group, size_t idx);
+
+  static void clearAll(detail::StrongVrtProxy proxy);
+  static void clearAll(detail::StrongObjGroup proxy);
+  static void clearAll(detail::StrongGroup group);
+
+private:
+  static inline std::unordered_map<VirtualProxyType, StatesInfo>
+    active_coll_states_ = {};
+
+  static inline std::unordered_map<ObjGroupProxyType, StatesInfo>
+    active_obj_states_ = {};
+
+  static inline std::unordered_map<GroupType, StatesInfo> active_grp_states_ =
+    {};
+};
+
+template <typename ReducerT, typename DataT>
+static inline auto& getState(ComponentInfo info, size_t id) {
+  if (info.first == ComponentT::VrtColl) {
+    return StateHolder::getState<ReducerT, DataT>(
+      detail::StrongVrtProxy{info.second}, id);
+  } else if (info.first == ComponentT::ObjGroup) {
+    return StateHolder::getState<ReducerT, DataT>(
+      detail::StrongObjGroup{info.second}, id);
+  } else {
+    return StateHolder::getState<ReducerT, DataT>(
+      detail::StrongGroup{info.second}, id);
+  }
+}
+
+static inline void cleanupState(ComponentInfo info, size_t id) {
+  if (info.first == ComponentT::VrtColl) {
+    StateHolder::clearSingle(detail::StrongVrtProxy{info.second}, id);
+  } else if (info.first == ComponentT::ObjGroup) {
+    StateHolder::clearSingle(detail::StrongObjGroup{info.second}, id);
+  } else {
+    StateHolder::clearSingle(detail::StrongGroup{info.second}, id);
+  }
+}
+
+} // namespace vt::collective::reduce::allreduce
+
+#include "state_holder.impl.h"
+
+#endif /*INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_STATE_HOLDER_H*/
diff --git a/src/vt/collective/reduce/allreduce/state_holder.impl.h b/src/vt/collective/reduce/allreduce/state_holder.impl.h
new file mode 100644
index 0000000000..f4bf85d0d4
--- /dev/null
+++ b/src/vt/collective/reduce/allreduce/state_holder.impl.h
@@ -0,0 +1,115 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                             state_holder.impl.h
+//                       DARMA/vt => Virtual Transport
+//
+// Copyright 2019-2024 National Technology & Engineering Solutions of Sandia, LLC
+// (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact darma@sandia.gov
+//
+// *****************************************************************************
+//@HEADER
+*/
+
+#if !defined INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_STATE_HOLDER_IMPL_H
+#define INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_STATE_HOLDER_IMPL_H
+
+#include "state_holder.h"
+#include "vt/configs/debug/debug_print.h"
+
+#include <type_traits>
+
+namespace vt::collective::reduce::allreduce {
+
+template <
+  typename StateT, typename DataT, typename Scalar, typename StateContainerT>
+static inline auto& getState(StateContainerT& states, size_t idx, uint64_t id) {
+  if (!states.at(idx)) {
+    vt_debug_print(
+      verbose, allreduce,
+      "Creating new allreduce state for id={:x} for idx={} "
+      "Scalar_typeid={} DataT_typeid={}\n",
+      id, idx, typeid(Scalar).name(), typeid(DataT).name());
+    states.at(idx) = std::make_unique<StateT>();
+  }
+
+  auto* ptr =
+    dynamic_cast<StateT*>(states.at(idx).get());
+  vtAssert(
+    ptr,
+    fmt::format(
+      "Invalid allreduce state cast for id={:x} idx={} Scalar_typeid={} "
+      "DataT_typeid={}\n",
+      idx, states.size(), typeid(Scalar).name(), typeid(DataT).name()));
+  return *ptr;
+}
+
+template <
+  typename ReduceT, typename DataT,
+  typename Scalar = typename DataHandler<DataT>::Scalar, typename ProxyT,
+  typename MapT>
+static auto& getStateImpl(ProxyT proxy, MapT& states_map, size_t idx) {
+  auto& [_, states] = states_map[proxy.get()];
+  auto const num_states = states.size();
+
+  if (idx >= num_states || num_states == 0) {
+    states.resize(idx + 1);
+  }
+
+  if constexpr (std::is_same_v<ReduceT, RabenseifnerT>) {
+    return getState<RabenseifnerState<Scalar, DataT>, DataT, Scalar>(
+      states, idx, proxy.get());
+  } else {
+    return getState<RecursiveDoublingState<DataT>, DataT, Scalar>(
+      states, idx, proxy.get());
+  }
+}
+
+template <typename ReducerT, typename DataT, typename Scalar>
+decltype(auto) StateHolder::getState(detail::StrongVrtProxy proxy, size_t idx) {
+  return getStateImpl<ReducerT, DataT>(proxy, active_coll_states_, idx);
+}
+
+template <typename ReducerT, typename DataT, typename Scalar>
+decltype(auto) StateHolder::getState(detail::StrongObjGroup proxy, size_t idx) {
+  return getStateImpl<ReducerT, DataT>(proxy, active_obj_states_, idx);
+}
+
+template <typename ReducerT, typename DataT, typename Scalar>
+decltype(auto) StateHolder::getState(detail::StrongGroup proxy, size_t idx) {
+  return getStateImpl<ReducerT, DataT>(proxy, active_grp_states_, idx);
+}
+
+} // namespace vt::collective::reduce::allreduce
+
+#endif /*INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_STATE_HOLDER_IMPL_H*/
diff --git a/src/vt/collective/reduce/allreduce/type.h b/src/vt/collective/reduce/allreduce/type.h
new file mode 100644
index 0000000000..4735972e92
--- /dev/null
+++ b/src/vt/collective/reduce/allreduce/type.h
@@ -0,0 +1,74 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                                    type.h
+//                       DARMA/vt => Virtual Transport
+//
+// Copyright 2019-2024 National Technology & Engineering Solutions of Sandia, LLC
+// (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact darma@sandia.gov
+//
+// *****************************************************************************
+//@HEADER
+*/
+
+#if !defined INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_TYPE_H
+#define INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_TYPE_H
+
+#include <string>
+
+namespace vt::collective::reduce::allreduce {
+
+struct RabenseifnerT {};
+struct RecursiveDoublingT {};
+
+enum class ReducerType { Rabenseifner, RecursiveDoubling };
+
+inline std::string TypeToString(ReducerType t) {
+  if (t == ReducerType::Rabenseifner) {
+    return "Rabenseifner";
+  } else {
+    return "RecursiveDoubling";
+  }
+}
+
+enum class ComponentT {
+  VrtColl = 0,
+  Group = 1,
+  ObjGroup = 2
+};
+
+using ComponentInfo = std::pair<ComponentT, uint64_t>;
+
+} // namespace vt::collective::reduce::allreduce
+
+#endif /*INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_TYPE_H*/
diff --git a/src/vt/collective/reduce/operators/functors/plus_op.h b/src/vt/collective/reduce/operators/functors/plus_op.h
index c3759447b6..b78b7720ff 100644
--- a/src/vt/collective/reduce/operators/functors/plus_op.h
+++ b/src/vt/collective/reduce/operators/functors/plus_op.h
@@ -47,6 +47,8 @@
 #include "vt/config.h"
 #include "vt/collective/reduce/operators/functors/tuple_op_helper.h"
 
+#include "vt/utils/kokkos/exec_space.h"
+
 namespace vt { namespace collective { namespace reduce { namespace operators {
 
 template <typename T>
@@ -65,10 +67,37 @@ struct PlusOp<std::tuple<Params...>> {
   }
 };
 
+#if MAGISTRATE_KOKKOS_ENABLED
+
+template <typename T, typename... Properties>
+struct PlusOp<Kokkos::View<T*, Properties...>> {
+  void operator()(
+    Kokkos::View<T*, Properties...>& v1,
+    const Kokkos::View<T*, Properties...>& v2) const {
+
+    // Determine the associated execution space based on the memory space
+    using MemorySpace = typename Kokkos::View<T*, Properties...>::memory_space;
+    using ExecSpace = typename utils::kokkos::AssociatedExecSpace<MemorySpace>::type;
+
+    Kokkos::RangePolicy<ExecSpace> policy(0, v1.extent(0));
+
+    Kokkos::parallel_for(
+      "Kokkos_PlusOp",
+      policy,
+      KOKKOS_LAMBDA(const int i) {
+        v1(i) += v2(i);
+      }
+    );
+
+    Kokkos::fence();
+  }
+};
+#endif // MAGISTRATE_KOKKOS_ENABLED
+
 template <typename T>
 struct PlusOp< std::vector<T> > {
   void operator()(std::vector<T>& v1, std::vector<T> const& v2) {
-    vtAssert(v1.size() == v2.size(), "Sizes of vectors in reduce must be equal");
+    vtAssert(v1.size() == v2.size(), fmt::format("Sizes of vectors in reduce must be equal v1={} v2={}", v1.size(), v2.size()));
     for (size_t ii = 0; ii < v1.size(); ++ii)
       v1[ii] = v1[ii] + v2[ii];
   }
diff --git a/src/vt/configs/arguments/app_config.h b/src/vt/configs/arguments/app_config.h
index 6548dc2fd1..dfd138649d 100644
--- a/src/vt/configs/arguments/app_config.h
+++ b/src/vt/configs/arguments/app_config.h
@@ -229,6 +229,7 @@ struct AppConfig {
   bool vt_debug_context      = false;
   bool vt_debug_epoch        = false;
   bool vt_debug_replay       = false;
+  bool vt_debug_allreduce    = false;
 
   bool vt_debug_print_flush = false;
 
@@ -394,6 +395,7 @@ struct AppConfig {
       | vt_debug_context
       | vt_debug_epoch
       | vt_debug_replay
+      | vt_debug_allreduce
 
       | vt_debug_print_flush
 
diff --git a/src/vt/configs/arguments/args.cc b/src/vt/configs/arguments/args.cc
index 2cde3f1710..4c12fbd8f9 100644
--- a/src/vt/configs/arguments/args.cc
+++ b/src/vt/configs/arguments/args.cc
@@ -816,6 +816,7 @@ void addDebugPrintArgs(CLI::App& app, AppConfig& appConfig) {
   auto ddp = "Enable debug_context      = \"" debug_pp(context)      "\"";
   auto dep = "Enable debug_epoch        = \"" debug_pp(epoch)        "\"";
   auto dfp = "Enable debug_replay       = \"" debug_pp(replay)       "\"";
+  auto dgp = "Enable debug_allreduce    = \"" debug_pp(allreduce)    "\"";
 
   auto r1 = app.add_option("--vt_debug_level",      appConfig.vt_debug_level,        rq);
 
@@ -853,6 +854,7 @@ void addDebugPrintArgs(CLI::App& app, AppConfig& appConfig) {
   auto dd = app.add_flag("--vt_debug_context",      appConfig.vt_debug_context,      ddp);
   auto de = app.add_flag("--vt_debug_epoch",        appConfig.vt_debug_epoch,        dep);
   auto df = app.add_flag("--vt_debug_replay",       appConfig.vt_debug_replay,       dfp);
+  auto dg = app.add_flag("--vt_debug_allreduce",    appConfig.vt_debug_allreduce,    dgp);
 
   auto debugGroup = "Debug Print Configuration (must be compile-time enabled)";
   r->group(debugGroup);
@@ -890,6 +892,7 @@ void addDebugPrintArgs(CLI::App& app, AppConfig& appConfig) {
   dd->group(debugGroup);
   de->group(debugGroup);
   df->group(debugGroup);
+  dg->group(debugGroup);
 
   auto dbq = "Always flush VT runtime prints";
   auto eb  = app.add_flag("--vt_debug_print_flush", appConfig.vt_debug_print_flush, dbq);
diff --git a/src/vt/configs/debug/debug_config.h b/src/vt/configs/debug/debug_config.h
index 6b579c5718..c3b0894a29 100644
--- a/src/vt/configs/debug/debug_config.h
+++ b/src/vt/configs/debug/debug_config.h
@@ -81,7 +81,8 @@ enum CatEnum : uint64_t {
   context      = 1ull<<29,
   epoch        = 1ull<<30,
   temperedwmin = 1ull<<31,
-  replay       = 1ull<<32
+  replay       = 1ull<<32,
+  allreduce    = 1ull<<33
 };
 
 enum CtxEnum : uint64_t {
@@ -149,6 +150,7 @@ vt_option_category_pretty_print(trace,        "trace")
 vt_option_category_pretty_print(vrt,          "vc")
 vt_option_category_pretty_print(vrt_coll,     "vcc")
 vt_option_category_pretty_print(worker,       "worker")
+vt_option_category_pretty_print(allreduce,    "allreduce")
 
 /*
  * Pretty print for CtxEnum output
diff --git a/src/vt/group/collective/group_collective_finished.cc b/src/vt/group/collective/group_collective_finished.cc
index e28851e971..27a092f01a 100644
--- a/src/vt/group/collective/group_collective_finished.cc
+++ b/src/vt/group/collective/group_collective_finished.cc
@@ -65,7 +65,7 @@ void InfoColl::CollSetupFinished::operator()(FinishedReduceMsg* msg) {
     info->known_root_node_ != this_node and
     info->known_root_node_ != uninitialized_destination
   ) {
-    auto nmsg = makeMessage<GroupOnlyMsg>(
+    auto nmsg = makeMessage<GroupCollectiveFinalMsg>(
       msg->getGroup(),info->new_tree_cont_
     );
     theMsg()->sendMsg<InfoColl::newTreeHan>(
diff --git a/src/vt/group/collective/group_collective_msg.h b/src/vt/group/collective/group_collective_msg.h
index fa52a492ac..748489858e 100644
--- a/src/vt/group/collective/group_collective_msg.h
+++ b/src/vt/group/collective/group_collective_msg.h
@@ -48,6 +48,8 @@
 #include "vt/group/group_common.h"
 #include "vt/group/msg/group_msg.h"
 #include "vt/messaging/message.h"
+#include "vt/configs/types/types_type.h"
+#include "vt/messaging/message/message_serialize.h"
 
 #include <cstdlib>
 
@@ -56,7 +58,7 @@ namespace vt { namespace group {
 template <typename MsgT>
 struct GroupCollectiveInfoMsg : MsgT {
   using MessageParentType = MsgT;
-  vt_msg_serialize_prohibited(); // no existing serialization function
+  vt_msg_serialize_required();
   static_assert(
     std::is_base_of<BaseMessage, MsgT>::value,
     "Base must derive from Message."
@@ -69,10 +71,11 @@ struct GroupCollectiveInfoMsg : MsgT {
     GroupType const& in_group, RemoteOperationIDType in_op, bool in_is_in_group,
     NodeType const& in_subtree,
     NodeType const& in_child_node = uninitialized_destination,
-    CountType const& level = 0, CountType const& extra_nodes = 0
+    CountType const& level = 0, CountType const& extra_nodes = 0,
+    std::set<NodeType> const& nodes = {}
   ) : MsgT(in_group, in_op), is_in_group(in_is_in_group),
       child_node_(in_child_node), subtree_size_(in_subtree),
-      extra_nodes_(extra_nodes), level_(level)
+      extra_nodes_(extra_nodes), level_(level), nodes_(nodes)
   { }
 
   NodeType getChild() const { return child_node_; }
@@ -81,6 +84,20 @@ struct GroupCollectiveInfoMsg : MsgT {
   bool isInGroup() const { return is_in_group; }
   CountType getExtraNodes() const { return extra_nodes_; }
   CountType getLevel() const { return level_; }
+  std::set<NodeType> const& getNodes() {return nodes_;}
+  void clearNodes() { nodes_.clear();}
+
+  template <typename SerializerT>
+  void serialize(SerializerT& s) {
+    MessageParentType::serialize(s);
+    s | is_in_group;
+    s | is_static_;
+    s | child_node_;
+    s | subtree_size_;
+    s | extra_nodes_;
+    s | level_;
+    s | nodes_;
+  }
 
 private:
   bool is_in_group = false;
@@ -89,9 +106,41 @@ struct GroupCollectiveInfoMsg : MsgT {
   NodeType subtree_size_ = 0;
   CountType extra_nodes_ = 0;
   CountType level_ = 0;
+  std::set<NodeType> nodes_ = {};
+};
+
+template <typename MsgT>
+struct GroupCollectiveFinalInfoMsg : MsgT {
+  using MessageParentType = MsgT;
+  vt_msg_serialize_required();
+
+  GroupCollectiveFinalInfoMsg() = default;
+  GroupCollectiveFinalInfoMsg(
+    GroupType const& in_group, RemoteOperationIDType const& in_op,
+    std::set<NodeType> const& nodes = {}
+  ) : MsgT(in_group, in_op), nodes_(nodes)
+  { }
+
+  GroupCollectiveFinalInfoMsg(
+    GroupType const& in_group, RemoteOperationIDType const& in_op,
+    NodeType const& in_root, bool const& in_default_group, std::set<NodeType> const& nodes = {}
+  ) : MsgT(in_group, in_op, in_root, in_default_group), nodes_(nodes)
+  { }
+
+  std::set<NodeType> const& getNodes() {return nodes_;}
+
+  template <typename SerializerT>
+  void serialize(SerializerT& s) {
+    MessageParentType::serialize(s);
+    s | nodes_;
+  }
+
+private:
+  std::set<NodeType> nodes_ = {};
 };
 
 using GroupCollectiveMsg = GroupCollectiveInfoMsg<GroupMsg<::vt::Message>>;
+using GroupCollectiveFinalMsg = GroupCollectiveFinalInfoMsg<GroupMsg<::vt::Message>>;
 
 }} /* end namespace vt::group */
 
diff --git a/src/vt/group/collective/group_info_collective.cc b/src/vt/group/collective/group_info_collective.cc
index 4aa6b7d810..a0c786d764 100644
--- a/src/vt/group/collective/group_info_collective.cc
+++ b/src/vt/group/collective/group_info_collective.cc
@@ -42,6 +42,7 @@
 */
 
 #include "vt/config.h"
+#include "vt/configs/types/types_type.h"
 #include "vt/group/group_common.h"
 #include "vt/group/base/group_info_base.h"
 #include "vt/group/collective/group_info_collective.h"
@@ -56,10 +57,12 @@
 #include "vt/collective/collective_alg.h"
 #include "vt/collective/collective_ops.h"
 #include "vt/pipe/pipe_headers.h"
+#include "vt/scheduler/scheduler.h"
 
 #include <memory>
 #include <set>
 #include <cstdlib>
+#include <string>
 #include <vector>
 #include <list>
 #include <algorithm>
@@ -136,6 +139,10 @@ void InfoColl::setupCollective() {
     is_in_group, group_, parent, children, coll_wait_count_
   );
 
+  if(is_in_group){
+    nodes_.insert({theContext()->getNode()});
+  }
+
   if (make_mpi_group_) {
     // Create the MPI group, and wait for all nodes to get here. In theory, this
     // might be overlapable with VT's group construction, but for now just wait
@@ -157,8 +164,9 @@ void InfoColl::setupCollective() {
   new_tree_cont_      = theGroup()->nextCollectiveID();
   new_root_cont_      = theGroup()->nextCollectiveID();
 
-  using GroupCollectiveTMsg = GroupManagerT<MsgSharedPtr<GroupCollectiveMsg>>;
-  using GroupOnlyTMsg       = GroupManagerT<MsgSharedPtr<GroupOnlyMsg>>;
+  using GroupCollectiveTMsg      = GroupManagerT<MsgSharedPtr<GroupCollectiveMsg>>;
+  using GroupOnlyTMsg            = GroupManagerT<MsgSharedPtr<GroupOnlyMsg>>;
+  using GroupCollectiveFinalTMsg = GroupManagerT<MsgSharedPtr<GroupCollectiveFinalMsg>>;
 
   GroupCollectiveTMsg::registerContinuationT(
     down_tree_cont_,
@@ -168,25 +176,25 @@ void InfoColl::setupCollective() {
       iter->second->downTree(msg.get());
     }
   );
-  GroupOnlyTMsg::registerContinuationT(
+  GroupCollectiveFinalTMsg::registerContinuationT(
     down_tree_fin_cont_,
-    [group_](MsgSharedPtr<GroupOnlyMsg> msg){
+    [group_](MsgSharedPtr<GroupCollectiveFinalMsg> msg){
       auto iter = theGroup()->local_collective_group_info_.find(group_);
       vtAssertExpr(iter != theGroup()->local_collective_group_info_.end());
       iter->second->downTreeFinished(msg.get());
     }
   );
-  GroupOnlyTMsg::registerContinuationT(
+  GroupCollectiveFinalTMsg::registerContinuationT(
     finalize_cont_,
-    [group_](MsgSharedPtr<GroupOnlyMsg> msg){
+    [group_](MsgSharedPtr<GroupCollectiveFinalMsg> msg){
       auto iter = theGroup()->local_collective_group_info_.find(group_);
       vtAssertExpr(iter != theGroup()->local_collective_group_info_.end());
       iter->second->finalizeTree(msg.get());
     }
   );
-  GroupOnlyTMsg::registerContinuationT(
+  GroupCollectiveFinalTMsg::registerContinuationT(
     new_tree_cont_,
-    [group_]([[maybe_unused]] MsgSharedPtr<GroupOnlyMsg> msg){
+    [group_]([[maybe_unused]] MsgSharedPtr<GroupCollectiveFinalMsg> msg){
       auto iter = theGroup()->local_collective_group_info_.find(group_);
       vtAssertExpr(iter != theGroup()->local_collective_group_info_.end());
       auto const& from = theContext()->getFromNodeCurrentTask();
@@ -215,17 +223,16 @@ void InfoColl::setupCollective() {
   GroupOnlyTMsg::triggerWaitingContinuations(new_tree_cont_);
   GroupCollectiveTMsg::triggerWaitingContinuations(up_tree_cont_);
 
-  vt_debug_print(
-    normal, group,
-    "InfoColl::setupCollective: is_in_group={}, parent={}: up tree\n",
-    is_in_group, parent
-  );
-
   if (collective_->getInitialChildren() == 0) {
+    vt_debug_print(
+      terse, group,
+      "InfoColl::setupCollective (group={:x}): Leaf {} sending to parent={}\n",
+      group_, theContext()->getNode(), parent
+    );
     auto const& size = static_cast<NodeType>(is_in_group ? 1 : 0);
     auto const& child = theContext()->getNode();
     auto msg = makeMessage<GroupCollectiveMsg>(
-      group_, up_tree_cont_, in_group, size, child
+      group_, up_tree_cont_, in_group, size, child, 0, 0, nodes_
     );
     theMsg()->sendMsg<upHan>(parent, msg);
   }
@@ -234,10 +241,17 @@ void InfoColl::setupCollective() {
 void InfoColl::atRoot() {
   auto const& is_root = collective_->isInitialRoot();
   auto const& group = getGroupID();
+    std::string nodes_info = "Nodes: ";
+  nodes_info.reserve(1024);
+  for(auto& node : nodes_){
+    nodes_info += fmt::format("{} ", node);
+  }
+  nodes_info += "\n";
+
   vt_debug_print(
-    normal, group,
-    "InfoColl::atRoot: is_in_group={}, group={:x}, root={}, children={}\n",
-    is_in_group, group, is_root, collective_->span_children_.size()
+    terse, group,
+    "InfoColl::atRoot: is_in_group={}, group={:x}, root={}, children={} nodes_={}\n",
+    is_in_group, group, is_root, collective_->span_children_.size(), nodes_info
   );
 }
 
@@ -248,10 +262,16 @@ void InfoColl::upTree() {
   );
   decltype(msgs_) msg_in_group = {};
   subtree_ = 0;
+
   for (auto&& msg : msgs_) {
+    for (auto& node : msg->getNodes()) {
+      nodes_.insert(node);
+    }
+
     if (msg->isInGroup()) {
       msg_in_group.push_back(msg);
       subtree_ += msg->getSubtreeSize();
+
     }
   }
 
@@ -269,6 +289,9 @@ void InfoColl::upTree() {
     coll_wait_count_, group, op, is_root, subtree_
   );
 
+  vt_debug_print(
+    terse, group, "InfoColl::upTree: group={:x}\n", group);
+
   if (is_root) {
     if (is_in_group) {
       auto const& this_node = theContext()->getNode();
@@ -369,13 +392,13 @@ void InfoColl::upTree() {
       msg_in_group.size() == 2 ? msg_in_group[0]->getLevel() + 1 : 0;
 
     vt_debug_print(
-      normal, group,
+      terse, group,
       "InfoColl::upTree: case 1: sub={}, total={}\n",
       subtree_, total_subtree
     );
 
     auto cmsg = makeMessage<GroupCollectiveMsg>(
-      group,op,is_in_group,total_subtree,child,level
+      group,op,is_in_group,total_subtree,child,level, 0, nodes_
     );
     theMsg()->sendMsg<upHan>(p, cmsg);
 
@@ -398,13 +421,13 @@ void InfoColl::upTree() {
     }
 
     vt_debug_print(
-      normal, group,
+      terse, group,
       "InfoColl::upTree: case 2: sub={} (total is same)\n",
       subtree_
     );
 
     auto msg = makeMessage<GroupCollectiveMsg>(
-      group,op,is_in_group,static_cast<NodeType>(subtree_),child,0,extra
+      group,op,is_in_group,static_cast<NodeType>(subtree_),child,0,extra, nodes_
     );
     theMsg()->sendMsg<upHan>(p, msg);
     /*
@@ -430,13 +453,13 @@ void InfoColl::upTree() {
     auto const total_subtree = static_cast<NodeType>(subtree_ + subtree_this);
 
     vt_debug_print(
-      normal, group,
+      terse, group,
       "InfoColl::upTree: case 3: sub={}, total={}\n",
       subtree_, total_subtree
     );
 
     auto msg = makeMessage<GroupCollectiveMsg>(
-      group,op,is_in_group,total_subtree,child,0,extra
+      group,op,is_in_group,total_subtree,child,0,extra, nodes_
     );
     theMsg()->sendMsg<upHan>(p, msg);
     // new MsgPtr to avoid thief of original in collection
@@ -470,18 +493,18 @@ void InfoColl::upTree() {
     auto const total_subtree = static_cast<NodeType>(subtree_this + subtree_);
 
     vt_debug_print(
-      normal, group,
+      terse, group,
       "InfoColl::upTree: case 4: sub={}, total={}\n",
       subtree_, total_subtree
     );
 
     auto msg = makeMessage<GroupCollectiveMsg>(
-      group,op,is_in_group,total_subtree,child,0,extra
+      group,op,is_in_group,total_subtree,child,0,extra, nodes_
     );
     theMsg()->sendMsg<upHan>(p, msg);
 
     vt_debug_print(
-      verbose, group,
+      terse, group,
       "InfoColl::upTree: msg_in_group.size()={}, msg_size.size()={}\n",
       msg_in_group.size(), msg_list.size()
     );
@@ -493,6 +516,8 @@ void InfoColl::upTree() {
     for (int i = 0; i < extra; i++) {
       GroupCollectiveMsg* tmsg = *iter;
       c[i] = tmsg->getChild();
+      // clear nodes information for extra nodes
+      // tmsg->clearNodes();
       auto pmsg = promoteMsg(tmsg);
       theMsg()->sendMsg<upHan>(p, pmsg);
       iter++;
@@ -584,7 +609,7 @@ void InfoColl::collectiveFn(MsgSharedPtr<GroupCollectiveMsg> msg) {
     (coll_wait_count_ == static_cast<WaitCountType>(arrived_count_) + 1);
 
   vt_debug_print(
-    verbose, group,
+    terse, group,
     "InfoColl::collectiveFn: group={:x}, arrived_count_={}, extra_count_={}, "
     "coll_wait_count_-1={}, ready={}\n",
     msg->getGroup(), arrived_count_, extra_count_, coll_wait_count_-1,
@@ -599,20 +624,20 @@ void InfoColl::collectiveFn(MsgSharedPtr<GroupCollectiveMsg> msg) {
   }
 }
 
-/*static*/ void InfoColl::tree(GroupOnlyMsg* msg) {
+/*static*/ void InfoColl::tree(GroupCollectiveFinalMsg* msg) {
   auto const& op_id = msg->getOpID();
   vtAssert(op_id != no_op_id, "Must have valid op");
   auto msg_ptr = promoteMsg(msg);
-  GroupManagerT<MsgSharedPtr<GroupOnlyMsg>>::triggerContinuationT(op_id,msg_ptr);
+  GroupManagerT<MsgSharedPtr<GroupCollectiveFinalMsg>>::triggerContinuationT(op_id,msg_ptr);
 }
 
 /*static*/ void InfoColl::upHan(GroupCollectiveMsg* msg) {
   envelopeUnlockForForwarding(msg->env);
 
   vt_debug_print(
-    verbose, group,
-    "InfoColl::upHan: group={:x}, op={:x}, child={}, extra={}\n",
-    msg->getGroup(), msg->getOpID(), msg->getChild(), msg->getExtraNodes()
+    terse, group,
+    "InfoColl::upHan: from={}, group={:x}, op={:x}, child={}, extra={}\n",
+    theContext()->getFromNodeCurrentTask(), msg->getGroup(), msg->getOpID(), msg->getChild(), msg->getExtraNodes()
   );
   auto const& op_id = msg->getOpID();
   vtAssert(op_id != no_op_id, "Must have valid op");
@@ -626,13 +651,19 @@ void InfoColl::downTree(GroupCollectiveMsg* msg) {
   auto const& from = theContext()->getFromNodeCurrentTask();
 
   vt_debug_print(
-    verbose, group,
-    "InfoColl::downTree: group={:x}, child={}, from={}\n",
-    getGroupID(), msg->getChild(), from
+    terse, group,
+    "InfoColl::downTree: group={:x}, child={}, from={} is_in_group={}\n",
+    getGroupID(), msg->getChild(), from, is_in_group
   );
 
   vtAssert(collective_ != nullptr, "Must be valid");
 
+  if (is_in_group) {
+    for (auto& node : msg->getNodes()) {
+      nodes_.insert(node);
+    }
+  }
+
   if (collective_->span_children_.size() < 4) {
     collective_->span_children_.push_back(msg->getChild());
   } else {
@@ -644,7 +675,7 @@ void InfoColl::downTree(GroupCollectiveMsg* msg) {
   }
 
   auto const& group_ = getGroupID();
-  auto nmsg = makeMessage<GroupOnlyMsg>(group_,down_tree_fin_cont_);
+  auto nmsg = makeMessage<GroupCollectiveFinalMsg>(group_,down_tree_fin_cont_, nodes_);
   theMsg()->sendMsg<downFinishedHan>(from, nmsg);
 }
 
@@ -685,7 +716,7 @@ void InfoColl::sendDownNewTree() {
       "InfoColl::sendDownNewTree: group={:x}, sending to child={}\n",
       group_, c
     );
-    auto msg = makeMessage<GroupOnlyMsg>(group_,new_tree_cont_);
+    auto msg = makeMessage<GroupCollectiveFinalMsg>(group_,new_tree_cont_, nodes_);
     theMsg()->sendMsg<newTreeHan>(c, msg);
   }
 }
@@ -706,7 +737,7 @@ void InfoColl::finalize() {
 
       auto const& num_children = collective_->span_children_.size();
       vt_debug_print(
-        verbose, group,
+        terse, group,
         "InfoColl::finalize: group={:x}, send_down_={}, "
         "send_down_finished_={}, in_phase_two_={}, in_group={}, "
         "has_root_={}, known_root_node_={}, is_new_root_={}, num={}, sub={},"
@@ -720,13 +751,13 @@ void InfoColl::finalize() {
     for (auto&& c : children) {
 
       vt_debug_print(
-        verbose, group,
+        terse, group,
         "InfoColl::finalize: group={:x}, sending to child={}\n",
         group_, c
       );
 
-      auto msg = makeMessage<GroupOnlyMsg>(
-        group_,finalize_cont_,known_root_node_,is_default_group_
+      auto msg = makeMessage<GroupCollectiveFinalMsg>(
+        group_,finalize_cont_, known_root_node_, is_default_group_, nodes_
       );
       theMsg()->sendMsg<finalizeHan>(c, msg);
     }
@@ -752,10 +783,10 @@ void InfoColl::finalize() {
   }
 }
 
-void InfoColl::finalizeTree(GroupOnlyMsg* msg) {
+void InfoColl::finalizeTree(GroupCollectiveFinalMsg* msg) {
   auto const& new_root = msg->getRoot();
   vt_debug_print(
-    verbose, group,
+    normal, group,
     "InfoColl::finalizeTree: group={:x}, new_root={}\n",
     msg->getGroup(), new_root
   );
@@ -763,11 +794,17 @@ void InfoColl::finalizeTree(GroupOnlyMsg* msg) {
   known_root_node_  = new_root;
   has_root_         = true;
   is_default_group_ = msg->isDefault();
+  for(auto& node : msg->getNodes()){
+    nodes_.insert(node);
+  }
   finalize();
 }
 
-void InfoColl::downTreeFinished([[maybe_unused]] GroupOnlyMsg* msg) {
+void InfoColl::downTreeFinished([[maybe_unused]] GroupCollectiveFinalMsg* msg) {
   send_down_finished_++;
+  for(auto& node : msg->getNodes()){
+    nodes_.insert(node);
+  }
   finalize();
 }
 
@@ -779,15 +816,15 @@ void InfoColl::downTreeFinished([[maybe_unused]] GroupOnlyMsg* msg) {
   return upHan(msg);
 }
 
-/*static*/ void InfoColl::downFinishedHan(GroupOnlyMsg* msg) {
+/*static*/ void InfoColl::downFinishedHan(GroupCollectiveFinalMsg* msg) {
   return tree(msg);
 }
 
-/*static*/ void InfoColl::finalizeHan(GroupOnlyMsg* msg) {
+/*static*/ void InfoColl::finalizeHan(GroupCollectiveFinalMsg* msg) {
   return tree(msg);
 }
 
-/*static*/ void InfoColl::newTreeHan(GroupOnlyMsg* msg) {
+/*static*/ void InfoColl::newTreeHan(GroupCollectiveFinalMsg* msg) {
   return tree(msg);
 }
 
diff --git a/src/vt/group/collective/group_info_collective.h b/src/vt/group/collective/group_info_collective.h
index c456dfdd97..c0980f1d79 100644
--- a/src/vt/group/collective/group_info_collective.h
+++ b/src/vt/group/collective/group_info_collective.h
@@ -105,10 +105,10 @@ struct InfoColl : virtual InfoBase {
   static void upHan(GroupCollectiveMsg* msg);
   static void downHan(GroupCollectiveMsg* msg);
   static void newRootHan(GroupCollectiveMsg* msg);
-  static void downFinishedHan(GroupOnlyMsg* msg);
-  static void finalizeHan(GroupOnlyMsg* msg);
-  static void newTreeHan(GroupOnlyMsg* msg);
-  static void tree(GroupOnlyMsg* msg);
+  static void downFinishedHan(GroupCollectiveFinalMsg* msg);
+  static void finalizeHan(GroupCollectiveFinalMsg* msg);
+  static void newTreeHan(GroupCollectiveFinalMsg* msg);
+  static void tree(GroupCollectiveFinalMsg* msg);
 
 private:
   void upTree();
@@ -116,8 +116,8 @@ struct InfoColl : virtual InfoBase {
   void downTree(GroupCollectiveMsg* msg);
   void collectiveFn(MsgSharedPtr<GroupCollectiveMsg> msg);
   void newRoot(GroupCollectiveMsg* msg);
-  void downTreeFinished(GroupOnlyMsg* msg);
-  void finalizeTree(GroupOnlyMsg* msg);
+  void downTreeFinished(GroupCollectiveFinalMsg* msg);
+  void finalizeTree(GroupCollectiveFinalMsg* msg);
   void finalize();
   void sendDownNewTree();
   void newTree(NodeType const& parent);
@@ -141,6 +141,7 @@ struct InfoColl : virtual InfoBase {
   bool is_default_group_                 = false;
   bool is_empty_group_                   = false;
   std::size_t subtree_                   = 0;
+  std::set<NodeType> nodes_              = {};
 
 private:
   RemoteOperationIDType down_tree_cont_     = no_op_id;
diff --git a/src/vt/group/group_manager.cc b/src/vt/group/group_manager.cc
index 647a056956..5372f91654 100644
--- a/src/vt/group/group_manager.cc
+++ b/src/vt/group/group_manager.cc
@@ -42,6 +42,8 @@
 */
 
 #include "vt/config.h"
+#include "vt/configs/types/types_sentinels.h"
+#include "vt/configs/types/types_type.h"
 #include "vt/context/context.h"
 #include "vt/group/group_common.h"
 #include "vt/group/group_manager.h"
@@ -140,6 +142,25 @@ bool GroupManager::inGroup(GroupType const group) {
   return iter->second->inGroup();
 }
 
+std::vector<NodeType>
+GroupManager::GetGroupNodes(GroupType const group_id) const {
+  if (isGroupDefault(group_id)) {
+    std::vector<NodeType> nodes(theContext()->getNumNodes());
+    for (NodeType i = 0; i < theContext()->getNumNodes(); ++i) {
+      nodes[i] = i;
+    }
+
+    return nodes;
+  } else {
+    // TODO Check if collective!
+    auto iter = local_collective_group_info_.find(group_id);
+    vtAssert(iter != local_collective_group_info_.end(), "Must exist");
+    auto& list = iter->second->nodes_;
+
+    return std::vector<NodeType>{list.begin(), list.end()};
+  }
+}
+
 GroupManager::ReducePtrType GroupManager::groupReducer(GroupType const group) {
   auto iter = local_collective_group_info_.find(group);
   vtAssert(iter != local_collective_group_info_.end(), "Must exist");
diff --git a/src/vt/group/group_manager.h b/src/vt/group/group_manager.h
index ec90a52e0e..325b5654c6 100644
--- a/src/vt/group/group_manager.h
+++ b/src/vt/group/group_manager.h
@@ -63,6 +63,7 @@
 #include "vt/collective/collective_scope.h"
 #include "vt/runtime/component/component_pack.h"
 #include "vt/utils/fntraits/fntraits.h"
+#include "vt/configs/types/types_type.h"
 
 #include <memory>
 #include <unordered_map>
@@ -198,6 +199,8 @@ struct GroupManager : runtime::component::Component<GroupManager> {
    */
   bool inGroup(GroupType const group);
 
+  std::vector<NodeType> GetGroupNodes(GroupType const group_id) const;
+
   /**
    * \brief Get MPI_Comm from VT group
    *
@@ -220,6 +223,10 @@ struct GroupManager : runtime::component::Component<GroupManager> {
     return sendMsg<MsgT, f>(group, msg);
   }
 
+  template <typename ReducerT, auto f, template <typename Arg> typename Op, typename ...Args>
+  void
+  allreduce(GroupType group, Args &&... args);
+
   friend struct Info;
   friend struct InfoColl;
   friend struct FinishedWork;
diff --git a/src/vt/group/group_manager.impl.h b/src/vt/group/group_manager.impl.h
index c78e56072d..75d567a76d 100644
--- a/src/vt/group/group_manager.impl.h
+++ b/src/vt/group/group_manager.impl.h
@@ -55,6 +55,13 @@
 #include "vt/messaging/active.h"
 #include "vt/activefn/activefn.h"
 #include "vt/group/group_info.h"
+#include "vt/collective/reduce/allreduce/state_holder.h"
+#include "vt/collective/reduce/allreduce/allreduce_holder.h"
+#include "vt/collective/reduce/allreduce/rabenseifner.h"
+#include "vt/collective/reduce/allreduce/recursive_doubling.h"
+#include "vt/objgroup/manager.h"
+#include "vt/pipe/pipe_manager.impl.h"
+#include "vt/collective/reduce/allreduce/type.h"
 
 namespace vt { namespace group {
 
@@ -155,6 +162,37 @@ void GroupManagerT<T>::triggerContinuationT(
   }
 }
 
+template <
+  typename ReducerT, auto f, template <typename Arg> typename Op,
+  typename... Args>
+void GroupManager::allreduce(GroupType group, Args&&... args) {
+  using namespace collective::reduce::allreduce;
+
+  auto iter = local_collective_group_info_.find(group);
+  vtAssert(
+    iter != local_collective_group_info_.end(),
+    "allreduce for groups is only supported for collective ones!");
+
+  using DataT =
+    std::tuple_element_t<0, typename FuncTraits<decltype(f)>::TupleType>;
+
+  if (iter->second->is_in_group) {
+    auto const strong_group = collective::reduce::detail::StrongGroup{group};
+    auto* reducer =
+      AllreduceHolder::getOrCreateAllreducer<ReducerT>(strong_group);
+
+    auto const this_node = theContext()->getNode();
+    auto id = StateHolder::getNextID(strong_group);
+
+    reducer->template setFinalHandler<DataT>(
+      theCB()->makeSend<f>(this_node), id);
+    reducer->template storeData<DataT, Op>(id, std::forward<Args>(args)...);
+    reducer->template run<DataT, Op>(id);
+
+    addCleanupAction([strong_group] { AllreduceHolder::remove(strong_group); });
+  }
+}
+
 }} /* end namespace vt::group */
 
 #endif /*INCLUDED_VT_GROUP_GROUP_MANAGER_IMPL_H*/
diff --git a/src/vt/group/msg/group_msg.h b/src/vt/group/msg/group_msg.h
index 04395c513d..e4c6377566 100644
--- a/src/vt/group/msg/group_msg.h
+++ b/src/vt/group/msg/group_msg.h
@@ -56,6 +56,8 @@ namespace vt { namespace group {
 
 template <typename MsgT>
 struct GroupMsg : MsgT {
+  using MessageParentType = MsgT;
+  vt_msg_serialize_if_needed_by_parent();
   GroupMsg() = default;
 
   GroupMsg(GroupType const& in_group, RemoteOperationIDType const& in_op)
@@ -78,6 +80,15 @@ struct GroupMsg : MsgT {
   void setOpID(RemoteOperationIDType const& op) { op_id_ = op; }
   void setRoot(NodeType const& root) { root_ = root; }
 
+  template <typename SerializerT>
+  void serialize(SerializerT& s) {
+    MessageParentType::serialize(s);
+    s | group_;
+    s | op_id_;
+    s | root_;
+    s | default_group_;
+  }
+
 protected:
   GroupType group_             = no_group;
   RemoteOperationIDType op_id_ = no_op_id;
diff --git a/src/vt/objgroup/manager.h b/src/vt/objgroup/manager.h
index 447cf2b6e0..66da122ba5 100644
--- a/src/vt/objgroup/manager.h
+++ b/src/vt/objgroup/manager.h
@@ -58,11 +58,13 @@
 #include "vt/messaging/pending_send.h"
 #include "vt/elm/elm_id.h"
 #include "vt/utils/fntraits/fntraits.h"
+#include "vt/utils/hash/hash_tuple.h"
 
 #include <memory>
 #include <functional>
 #include <unordered_map>
 #include <vector>
+#include <typeindex>
 
 namespace vt { namespace objgroup {
 
@@ -91,6 +93,11 @@ struct ObjGroupManager : runtime::component::Component<ObjGroupManager> {
   using HolderBaseType      = holder::HolderBase;
   using HolderBasePtrType   = std::unique_ptr<HolderBaseType>;
   using PendingSendType     = messaging::PendingSend;
+  using ReduceDataType      = std::type_index;
+  using ReduceOperandType   = std::type_index;
+  using ReducerMapType      = std::unordered_map<
+    std::tuple<ObjGroupProxyType, ReduceDataType, ReduceOperandType>,
+    ObjGroupProxyType>;
 
 public:
   /**
@@ -291,6 +298,13 @@ struct ObjGroupManager : runtime::component::Component<ObjGroupManager> {
     ProxyType<ObjT> proxy, std::string const& name, std::string const& parent = ""
   );
 
+  template <
+    typename Type, auto f, template <typename Arg> class Op, typename ObjT,
+    typename... Args
+  >
+  ObjGroupManager::PendingSendType
+  allreduce(ProxyType<ObjT> proxy, Args&&... data);
+
   /**
    * \brief Perform a reduction over an objgroup
    *
diff --git a/src/vt/objgroup/manager.impl.h b/src/vt/objgroup/manager.impl.h
index 26ae714e04..bf40d9d952 100644
--- a/src/vt/objgroup/manager.impl.h
+++ b/src/vt/objgroup/manager.impl.h
@@ -57,7 +57,17 @@
 #include "vt/collective/collective_alg.h"
 #include "vt/messaging/active.h"
 #include "vt/elm/elm_id_bits.h"
-
+#include "vt/messaging/message/smart_ptr.h"
+#include "vt/collective/reduce/allreduce/rabenseifner.h"
+#include "vt/collective/reduce/allreduce/recursive_doubling.h"
+#include "vt/collective/reduce/allreduce/type.h"
+#include "vt/collective/reduce/allreduce/helpers.h"
+#include "vt/collective/reduce/scoping/strong_types.h"
+#include "vt/collective/reduce/allreduce/allreduce_holder.h"
+#include "vt/pipe/pipe_manager.h"
+
+#include <utility>
+#include <array>
 #include <memory>
 
 namespace vt { namespace objgroup {
@@ -137,6 +147,10 @@ void ObjGroupManager::destroyCollective(ProxyType<ObjT> proxy) {
   if (label_iter != labels_.end()) {
     labels_.erase(label_iter);
   }
+
+  vt::collective::reduce::allreduce::AllreduceHolder::remove(
+    vt::collective::reduce::detail::StrongObjGroup{proxy.getProxy()}
+  );
 }
 
 template <typename ObjT>
@@ -262,6 +276,34 @@ ObjGroupManager::PendingSendType ObjGroupManager::broadcast(MsgSharedPtr<MsgT> m
   return objgroup::broadcast(msg,han);
 }
 
+  template <
+    typename Type, auto f, template <typename Arg> class Op, typename ObjT,
+    typename... Args
+  >
+ObjGroupManager::PendingSendType
+ObjGroupManager::allreduce(ProxyType<ObjT> proxy, Args&&... data) {
+  using namespace collective::reduce::allreduce;
+
+  using Trait = ObjFuncTraits<decltype(f)>;
+
+  // We only support allreduce with a single data type
+  using DataT = typename std::tuple_element<0, typename Trait::TupleType>::type;
+
+  auto const strong_proxy = vt::collective::reduce::detail::StrongObjGroup{proxy.getProxy()};
+  auto const id = StateHolder::getNextID(strong_proxy);
+
+  auto* reducer = AllreduceHolder::getOrCreateAllreducer<Type>(strong_proxy);
+
+  auto cb = theCB()->makeSend<f>(proxy[theContext()->getNode()]);
+  reducer->template setFinalHandler<DataT>(cb, id);
+  reducer->template storeData<DataT, Op>(
+    id, std::forward<Args>(data)...);
+
+  return PendingSendType{theTerm()->getEpoch(), [reducer, id] {
+                           reducer->template run<DataT, Op>(id);
+                         }};
+}
+
 template <typename ObjT, typename MsgT, ActiveTypedFnType<MsgT> *f>
 ObjGroupManager::PendingSendType ObjGroupManager::reduce(
   ProxyType<ObjT> proxy, MsgSharedPtr<MsgT> msg,
diff --git a/src/vt/objgroup/proxy/proxy_objgroup.h b/src/vt/objgroup/proxy/proxy_objgroup.h
index 825c652df0..40f297684b 100644
--- a/src/vt/objgroup/proxy/proxy_objgroup.h
+++ b/src/vt/objgroup/proxy/proxy_objgroup.h
@@ -60,6 +60,7 @@
 #include "vt/messaging/pending_send.h"
 #include "vt/utils/fntraits/fntraits.h"
 #include "vt/group/region/group_list.h"
+#include "vt/collective/reduce/allreduce/type.h"
 
 namespace vt { namespace objgroup { namespace proxy {
 
@@ -198,6 +199,16 @@ struct Proxy {
     Args&&... args
   ) const;
 
+  template <
+    auto f,
+    template <typename Arg> class Op = collective::NoneOp,
+    typename Type,
+    typename... Args
+  >
+  PendingSendType allreduce(
+    Args&&... args
+  ) const;
+
   /**
    * \brief Reduce back to a point target. Performs a reduction using operator
    * `Op` followed by a send to `f` with the result.
diff --git a/src/vt/objgroup/proxy/proxy_objgroup.impl.h b/src/vt/objgroup/proxy/proxy_objgroup.impl.h
index 337f9fcaab..d871d1f4f5 100644
--- a/src/vt/objgroup/proxy/proxy_objgroup.impl.h
+++ b/src/vt/objgroup/proxy/proxy_objgroup.impl.h
@@ -56,6 +56,7 @@
 #include "vt/messaging/param_msg.h"
 #include "vt/objgroup/proxy/proxy_bits.h"
 #include "vt/collective/reduce/get_reduce_stamp.h"
+#include "vt/collective/reduce/allreduce/helpers.h"
 
 namespace vt { namespace objgroup { namespace proxy {
 
@@ -203,6 +204,23 @@ Proxy<ObjT>::allreduce(
   >(proxy, msg.get(), stamp);
 }
 
+template <typename ObjT>
+template <
+  auto f,
+  template <typename Arg> class Op,
+  typename Type,
+  typename... Args
+>
+typename Proxy<ObjT>::PendingSendType
+Proxy<ObjT>::allreduce(
+  Args&&... args
+) const {
+  auto proxy = Proxy<ObjT>(*this);
+
+  return theObjGroup()->allreduce<Type, f, Op>(
+    proxy, std::forward<Args>(args)...);
+}
+
 template <typename ObjT>
 template <
   auto f,
diff --git a/src/vt/pipe/callback/cb_union/cb_raw.h b/src/vt/pipe/callback/cb_union/cb_raw.h
index ba5143693c..96d54aadcd 100644
--- a/src/vt/pipe/callback/cb_union/cb_raw.h
+++ b/src/vt/pipe/callback/cb_union/cb_raw.h
@@ -85,6 +85,16 @@ struct BcastColMsgCB : CallbackProxyBcastTypeless {
   BcastColMsgCB() = default;
 };
 
+struct CollLocalSendDirCB : CallbackProxyLocalSendCollDirect {
+  CollLocalSendDirCB() = default;
+  CollLocalSendDirCB(
+    HandlerType const in_handler,
+    CallbackProxyLocalSendCollDirect::AutoHandlerType const in_vrt_handler,
+    VirtualProxyType const& in_proxy
+  ) : CallbackProxyLocalSendCollDirect(in_handler, in_vrt_handler, in_proxy)
+  { }
+};
+
 struct BcastColDirCB : CallbackProxyBcastDirect {
   BcastColDirCB() = default;
   BcastColDirCB(
@@ -120,15 +130,16 @@ union CallbackUnion {
   CallbackUnion(CallbackUnion&&) = default;
   CallbackUnion& operator=(CallbackUnion const&) = default;
 
-  explicit CallbackUnion(SendMsgCB const& in)       : send_msg_cb_(in)      { }
-  explicit CallbackUnion(BcastMsgCB const& in)      : bcast_msg_cb_(in)     { }
-  explicit CallbackUnion(SendColMsgCB const& in)    : send_col_msg_cb_(in)  { }
-  explicit CallbackUnion(BcastColMsgCB const& in)   : bcast_col_msg_cb_(in) { }
-  explicit CallbackUnion(BcastColDirCB const& in)   : bcast_col_dir_cb_(in) { }
-  explicit CallbackUnion(SendColDirCB const& in)    : send_col_dir_cb_(in)  { }
-  explicit CallbackUnion(AnonCB const& in)          : anon_cb_(in)          { }
-  explicit CallbackUnion(BcastObjGrpCB const& in)   : bcast_obj_cb_(in)     { }
-  explicit CallbackUnion(SendObjGrpCB const& in)    : send_obj_cb_(in)      { }
+  explicit CallbackUnion(SendMsgCB const& in)          : send_msg_cb_(in)      { }
+  explicit CallbackUnion(BcastMsgCB const& in)         : bcast_msg_cb_(in)     { }
+  explicit CallbackUnion(SendColMsgCB const& in)       : send_col_msg_cb_(in)  { }
+  explicit CallbackUnion(BcastColMsgCB const& in)      : bcast_col_msg_cb_(in) { }
+  explicit CallbackUnion(BcastColDirCB const& in)      : bcast_col_dir_cb_(in) { }
+  explicit CallbackUnion(CollLocalSendDirCB const& in) : coll_bcast_col_dir_cb_(in) { }
+  explicit CallbackUnion(SendColDirCB const& in)       : send_col_dir_cb_(in)  { }
+  explicit CallbackUnion(AnonCB const& in)             : anon_cb_(in)          { }
+  explicit CallbackUnion(BcastObjGrpCB const& in)      : bcast_obj_cb_(in)     { }
+  explicit CallbackUnion(SendObjGrpCB const& in)       : send_obj_cb_(in)      { }
 
   AnonCB        anon_cb_;
   SendMsgCB     send_msg_cb_;
@@ -136,22 +147,24 @@ union CallbackUnion {
   SendColMsgCB  send_col_msg_cb_;
   BcastColMsgCB bcast_col_msg_cb_;
   BcastColDirCB bcast_col_dir_cb_;
+  CollLocalSendDirCB coll_bcast_col_dir_cb_;
   SendColDirCB  send_col_dir_cb_;
   BcastObjGrpCB bcast_obj_cb_;
   SendObjGrpCB  send_obj_cb_;
 };
 
 enum struct CallbackEnum : int8_t {
-  NoCB          = 0,
-  SendMsgCB     = 1,
-  BcastMsgCB    = 2,
-  SendColMsgCB  = 3,
-  BcastColMsgCB = 4,
-  BcastColDirCB = 5,
-  SendColDirCB  = 6,
-  AnonCB        = 7,
-  BcastObjGrpCB = 8,
-  SendObjGrpCB  = 9
+  NoCB               = 0,
+  SendMsgCB          = 1,
+  BcastMsgCB         = 2,
+  SendColMsgCB       = 3,
+  BcastColMsgCB      = 4,
+  CollLocalSendDirCB = 5,
+  BcastColDirCB      = 6,
+  SendColDirCB       = 7,
+  AnonCB             = 8,
+  BcastObjGrpCB      = 9,
+  SendObjGrpCB       = 10
 };
 
 struct GeneralCallback {
@@ -172,6 +185,9 @@ struct GeneralCallback {
   explicit GeneralCallback(BcastColMsgCB const& in)
     : u_(in), active_(CallbackEnum::BcastColMsgCB)
   { }
+  explicit GeneralCallback(CollLocalSendDirCB const& in)
+    : u_(in), active_(CallbackEnum::CollLocalSendDirCB)
+  { }
   explicit GeneralCallback(AnonCB const& in)
     : u_(in), active_(CallbackEnum::AnonCB)
   { }
@@ -204,6 +220,8 @@ struct GeneralCallback {
         return u_.bcast_col_msg_cb_ == other.u_.bcast_col_msg_cb_;
       case CallbackEnum::BcastColDirCB:
         return u_.bcast_col_dir_cb_ == other.u_.bcast_col_dir_cb_;
+      case CallbackEnum::CollLocalSendDirCB:
+        return u_.coll_bcast_col_dir_cb_ == other.u_.coll_bcast_col_dir_cb_;
       case CallbackEnum::BcastObjGrpCB:
         return u_.bcast_obj_cb_ == other.u_.bcast_obj_cb_;
       case CallbackEnum::SendObjGrpCB:
@@ -244,6 +262,9 @@ struct GeneralCallback {
     case CallbackEnum::BcastColMsgCB:
       ser(u_.bcast_col_msg_cb_);
       break;
+    case CallbackEnum::CollLocalSendDirCB:
+      ser(u_.bcast_col_msg_cb_);
+      break;
     case CallbackEnum::BcastColDirCB:
       ser(u_.bcast_col_dir_cb_);
       break;
diff --git a/src/vt/pipe/callback/cb_union/cb_raw_base.cc b/src/vt/pipe/callback/cb_union/cb_raw_base.cc
index 0ea7cc74cd..2ddb0b4850 100644
--- a/src/vt/pipe/callback/cb_union/cb_raw_base.cc
+++ b/src/vt/pipe/callback/cb_union/cb_raw_base.cc
@@ -73,6 +73,12 @@ CallbackRawBaseSingle::CallbackRawBaseSingle(
 ) : pipe_(in_pipe), cb_(BcastColMsgCB{})
 { }
 
+CallbackRawBaseSingle::CallbackRawBaseSingle(
+  RawSendLocalCollTagType, PipeType const& in_pipe, HandlerType const in_handler,
+  AutoHandlerType const in_vrt, VirtualProxyType const& in_proxy
+) : pipe_(in_pipe), cb_(CollLocalSendDirCB{in_handler, in_vrt, in_proxy})
+{ }
+
 CallbackRawBaseSingle::CallbackRawBaseSingle(
   RawBcastColDirTagType, PipeType const& in_pipe, HandlerType const in_handler,
   AutoHandlerType const in_vrt, VirtualProxyType const& in_proxy
diff --git a/src/vt/pipe/callback/cb_union/cb_raw_base.h b/src/vt/pipe/callback/cb_union/cb_raw_base.h
index 6037cc5f1a..f321fc5e49 100644
--- a/src/vt/pipe/callback/cb_union/cb_raw_base.h
+++ b/src/vt/pipe/callback/cb_union/cb_raw_base.h
@@ -58,15 +58,16 @@ namespace vt { namespace pipe { namespace callback { namespace cbunion {
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wunused-variable"
-static struct RawAnonTagType        { } RawAnonTag        { };
-static struct RawSendMsgTagType     { } RawSendMsgTag     { };
-static struct RawBcastMsgTagType    { } RawBcastMsgTag    { };
-static struct RawSendColMsgTagType  { } RawSendColMsgTag  { };
-static struct RawBcastColMsgTagType { } RawBcastColMsgTag { };
-static struct RawSendColDirTagType  { } RawSendColDirTag  { };
-static struct RawBcastColDirTagType { } RawBcastColDirTag { };
-static struct RawSendObjGrpTagType  { } RawSendObjGrpTag  { };
-static struct RawBcastObjGrpTagType { } RawBcastObjGrpTag { };
+static struct RawAnonTagType          { } RawAnonTag          { };
+static struct RawSendMsgTagType       { } RawSendMsgTag       { };
+static struct RawBcastMsgTagType      { } RawBcastMsgTag      { };
+static struct RawSendColMsgTagType    { } RawSendColMsgTag    { };
+static struct RawBcastColMsgTagType   { } RawBcastColMsgTag   { };
+static struct RawSendColDirTagType    { } RawSendColDirTag    { };
+static struct RawBcastColDirTagType   { } RawBcastColDirTag   { };
+static struct RawSendLocalCollTagType { } RawSendLocalCollTag { };
+static struct RawSendObjGrpTagType    { } RawSendObjGrpTag    { };
+static struct RawBcastObjGrpTagType   { } RawBcastObjGrpTag   { };
 #pragma GCC diagnostic pop
 
 template <typename... Args>
@@ -95,6 +96,11 @@ struct CallbackRawBaseSingle {
   CallbackRawBaseSingle(RawAnonTagType, PipeType const& in_pipe);
   CallbackRawBaseSingle(RawSendColMsgTagType, PipeType const& in_pipe);
   CallbackRawBaseSingle(RawBcastColMsgTagType, PipeType const& in_pipe);
+  CallbackRawBaseSingle(
+    RawSendLocalCollTagType, PipeType const& in_pipe,
+    HandlerType const in_handler, AutoHandlerType const in_vrt,
+    VirtualProxyType const& in_proxy
+  );
   CallbackRawBaseSingle(
     RawBcastColDirTagType, PipeType const& in_pipe,
     HandlerType const in_handler, AutoHandlerType const in_vrt,
@@ -187,6 +193,16 @@ struct CallbackTyped : CallbackRawBaseSingle {
   CallbackTyped(RawBcastColMsgTagType, PipeType const& in_pipe)
     : CallbackRawBaseSingle(RawBcastColMsgTag,in_pipe)
   { }
+
+  CallbackTyped(
+    RawSendLocalCollTagType, PipeType const& in_pipe,
+    HandlerType const in_handler, AutoHandlerType const in_vrt,
+    VirtualProxyType const& in_proxy
+  ) : CallbackRawBaseSingle(
+        RawSendLocalCollTag, in_pipe, in_handler, in_vrt, in_proxy
+      )
+  { }
+
   CallbackTyped(
     RawBcastColDirTagType, PipeType const& in_pipe,
     HandlerType const in_handler, AutoHandlerType const in_vrt,
diff --git a/src/vt/pipe/callback/cb_union/cb_raw_base.impl.h b/src/vt/pipe/callback/cb_union/cb_raw_base.impl.h
index 6bad1cf4a4..180962ff67 100644
--- a/src/vt/pipe/callback/cb_union/cb_raw_base.impl.h
+++ b/src/vt/pipe/callback/cb_union/cb_raw_base.impl.h
@@ -88,6 +88,9 @@ void CallbackRawBaseSingle::sendMsg(MsgT* msg) {
   case CallbackEnum::BcastColDirCB:
     cb_.u_.bcast_col_dir_cb_.trigger<MsgT>(msg,pipe_);
     break;
+  case CallbackEnum::CollLocalSendDirCB:
+    cb_.u_.coll_bcast_col_dir_cb_.trigger<MsgT>(msg,pipe_);
+    break;
   case CallbackEnum::SendObjGrpCB:
     cb_.u_.send_obj_cb_.trigger<MsgT>(msg,pipe_);
     break;
diff --git a/src/vt/pipe/callback/proxy_bcast/callback_proxy_bcast_tl.h b/src/vt/pipe/callback/proxy_bcast/callback_proxy_bcast_tl.h
index 67b966d675..adc80a805a 100644
--- a/src/vt/pipe/callback/proxy_bcast/callback_proxy_bcast_tl.h
+++ b/src/vt/pipe/callback/proxy_bcast/callback_proxy_bcast_tl.h
@@ -106,6 +106,40 @@ struct CallbackProxyBcastDirect : CallbackBaseTL<CallbackProxyBcastDirect> {
   VirtualProxyType proxy_           = no_vrt_proxy;
 };
 
+struct CallbackProxyLocalSendCollDirect : CallbackBaseTL<CallbackProxyLocalSendCollDirect> {
+  using AutoHandlerType = auto_registry::AutoHandlerType;
+
+  CallbackProxyLocalSendCollDirect() = default;
+  CallbackProxyLocalSendCollDirect(
+    HandlerType const in_han, AutoHandlerType const in_vrt,
+    VirtualProxyType const& in_proxy
+  ) : vrt_dispatch_han_(in_vrt), handler_(in_han), proxy_(in_proxy)
+  { }
+
+  template <typename SerializerT>
+  void serialize(SerializerT& s);
+
+  bool operator==(CallbackProxyLocalSendCollDirect const& other) const {
+    return
+      other.handler_ == handler_ &&
+      other.vrt_dispatch_han_ == vrt_dispatch_han_ &&
+      other.proxy_ == proxy_;
+  }
+
+public:
+  template <typename MsgT>
+  void trigger(MsgT* msg, PipeType const& pipe);
+
+  void triggerVoid([[maybe_unused]] PipeType const& pipe) {
+    vtAssert(0, "Must not be void");
+  }
+
+private:
+  AutoHandlerType vrt_dispatch_han_ = uninitialized_handler;
+  HandlerType handler_              = uninitialized_handler;
+  VirtualProxyType proxy_           = no_vrt_proxy;
+};
+
 }}} /* end namespace vt::pipe::callback */
 
 #include "vt/pipe/callback/handler_bcast/callback_bcast_tl.impl.h"
diff --git a/src/vt/pipe/callback/proxy_bcast/callback_proxy_bcast_tl.impl.h b/src/vt/pipe/callback/proxy_bcast/callback_proxy_bcast_tl.impl.h
index f0e20d7dc1..aa8d275ec4 100644
--- a/src/vt/pipe/callback/proxy_bcast/callback_proxy_bcast_tl.impl.h
+++ b/src/vt/pipe/callback/proxy_bcast/callback_proxy_bcast_tl.impl.h
@@ -109,6 +109,28 @@ void CallbackProxyBcastDirect::trigger(MsgT* msg, PipeType const& pipe) {
   dispatcher->broadcast(proxy, reinterpret_cast<std::byte*>(msg), handler_);
 }
 
+template <typename SerializerT>
+void CallbackProxyLocalSendCollDirect::serialize(SerializerT& s) {
+  s | handler_;
+  s | vrt_dispatch_han_;
+  s | proxy_;
+}
+
+template <typename MsgT>
+void CallbackProxyLocalSendCollDirect::trigger(MsgT* msg, PipeType const& pipe) {
+  auto const& this_node = theContext()->getNode();
+  vt_debug_print(
+    terse, pipe,
+    "CallbackProxyLocalSendCollDirect: trigger_: pipe={:x}, this_node={}, "
+    "handler={}, vrt_handler={}\n",
+    pipe, this_node, handler_, vrt_dispatch_han_
+  );
+
+  auto dispatcher = vrt::collection::getDispatcher(vrt_dispatch_han_);
+  auto const& proxy = proxy_;
+  dispatcher->broadcastCollective(proxy, reinterpret_cast<std::byte*>(msg), handler_);
+}
+
 }}} /* end namespace vt::pipe::callback */
 
 #endif /*INCLUDED_VT_PIPE_CALLBACK_PROXY_BCAST_CALLBACK_PROXY_BCAST_TL_IMPL_H*/
diff --git a/src/vt/pipe/pipe_manager.h b/src/vt/pipe/pipe_manager.h
index 5ebd21018f..4b118e2791 100644
--- a/src/vt/pipe/pipe_manager.h
+++ b/src/vt/pipe/pipe_manager.h
@@ -135,6 +135,16 @@ struct PipeManager
   template <auto f, typename ProxyT>
   auto makeBcast(ProxyT proxy);
 
+  /**
+   * \brief Make collective broadcast callback to collection
+   *
+   * \param[in] proxy the proxy to target
+   *
+   * \return a callback
+   */
+  template <auto f, typename ProxyT>
+  auto makeSendLocalCollectionElement(ProxyT proxy);
+
   /**
    * \brief Make callback to a function (including lambdas) with a context
    * pointer to any object on this node.
diff --git a/src/vt/pipe/pipe_manager.impl.h b/src/vt/pipe/pipe_manager.impl.h
index afe4524e5e..e1adceaa2a 100644
--- a/src/vt/pipe/pipe_manager.impl.h
+++ b/src/vt/pipe/pipe_manager.impl.h
@@ -154,6 +154,11 @@ auto PipeManager::makeBcast(ProxyT proxy) {
   return makeCallbackProxy<f, true>(proxy);
 }
 
+template <auto f, typename ProxyT>
+auto PipeManager::makeSendLocalCollectionElement(ProxyT proxy) {
+  return makeCallbackBcastCollectiveProxy<f>(proxy);
+}
+
 template <typename MsgT, ActiveTypedFnType<MsgT>* f>
 Callback<MsgT> PipeManager::makeBcast() {
   return makeCallbackSingle<f, true>();
diff --git a/src/vt/pipe/pipe_manager_tl.h b/src/vt/pipe/pipe_manager_tl.h
index 4dc340652d..e6a1a7afcf 100644
--- a/src/vt/pipe/pipe_manager_tl.h
+++ b/src/vt/pipe/pipe_manager_tl.h
@@ -113,6 +113,9 @@ struct PipeManagerTL : virtual PipeManagerBase {
   template <auto f, bool is_bcast, typename ProxyT>
   auto makeCallbackProxy(ProxyT proxy);
 
+  template <auto f, typename ProxyT>
+  auto makeCallbackBcastCollectiveProxy(ProxyT proxy);
+
   // Multi-staged callback
   template <typename=void>
   CallbackType makeCallback();
diff --git a/src/vt/pipe/pipe_manager_tl.impl.h b/src/vt/pipe/pipe_manager_tl.impl.h
index f1364483a2..4a258c3c40 100644
--- a/src/vt/pipe/pipe_manager_tl.impl.h
+++ b/src/vt/pipe/pipe_manager_tl.impl.h
@@ -141,6 +141,46 @@ void PipeManagerTL::addListenerFunctorBcast(
 template <typename U>
 using hasIdx_t = typename U::IndexType;
 
+template <auto f, typename ProxyT>
+auto PipeManagerTL::makeCallbackBcastCollectiveProxy(ProxyT proxy) {
+  bool const persist = true;
+  bool const send_back = false;
+  bool const dispatch = true;
+  auto const pipe_id = makePipeID(persist, send_back);
+  newPipeState(pipe_id, persist, dispatch, -1, -1, 0);
+
+  using Trait = ObjFuncTraits<decltype(f)>;
+  using ColT = typename Trait::ObjT;
+  using MsgT = typename Trait::MsgT;
+  using RetType = typename Trait::template WrapType<CallbackRetType>;
+
+  HandlerType han = uninitialized_handler;
+  vrt::collection::AutoHandlerType vrt_handler = uninitialized_handler;
+
+  if constexpr (std::is_same_v<MsgT, NoMsg>) {
+    using Tuple = typename Trait::TupleType;
+    using NormMsgT = messaging::ParamMsg<Tuple>;
+    using WrapMsgT = vrt::collection::ColMsgWrap<ColT, NormMsgT, vt::Message>;
+    han = auto_registry::makeAutoHandlerCollectionMemParam<
+      ColT, decltype(f), f, WrapMsgT>();
+
+    vrt_handler = vrt::collection::makeVrtDispatch<NormMsgT, ColT>();
+
+  } else {
+    if constexpr (Trait::is_member) {
+      han = auto_registry::makeAutoHandlerCollectionMem<ColT, MsgT, f>();
+    } else {
+      han = auto_registry::makeAutoHandlerCollection<ColT, MsgT, f>();
+    }
+
+    vrt_handler = vrt::collection::makeVrtDispatch<MsgT, ColT>();
+  }
+
+  return RetType{
+      callback::cbunion::RawSendLocalCollTag, pipe_id, han, vrt_handler,
+      proxy.getProxy()};
+}
+
 template <auto f, bool is_bcast, typename ProxyT>
 auto PipeManagerTL::makeCallbackProxy(ProxyT proxy) {
   bool const persist = true;
diff --git a/src/vt/utils/kokkos/exec_space.h b/src/vt/utils/kokkos/exec_space.h
new file mode 100644
index 0000000000..7650a9aae9
--- /dev/null
+++ b/src/vt/utils/kokkos/exec_space.h
@@ -0,0 +1,73 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                                 exec_space.h
+//                       DARMA/vt => Virtual Transport
+//
+// Copyright 2019-2024 National Technology & Engineering Solutions of Sandia, LLC
+// (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact darma@sandia.gov
+//
+// *****************************************************************************
+//@HEADER
+*/
+
+#if !defined INCLUDED_VT_UTILS_KOKKOS_EXEC_SPACE_H
+#define INCLUDED_VT_UTILS_KOKKOS_EXEC_SPACE_H
+
+#include "vt/config.h"
+
+#if MAGISTRATE_KOKKOS_ENABLED
+
+#include <Kokkos_Core.hpp>
+
+namespace vt::utils::kokkos {
+
+template <typename MemorySpace>
+struct AssociatedExecSpace;
+
+template <>
+struct AssociatedExecSpace<Kokkos::HostSpace> {
+  // TODO: check whether OpenMPi is available?
+  using type = Kokkos::Serial;
+};
+
+#ifdef KOKKOS_ENABLE_CUDA
+template <>
+struct AssociatedExecSpace<Kokkos::CudaSpace> {
+  using type = Kokkos::Cuda;
+};
+#endif // KOKKOS_ENABLE_CUDA
+}
+
+#endif // MAGISTRATE_KOKKOS_ENABLED
+#endif /*INCLUDED_VT_UTILS_KOKKOS_EXEC_SPACE_H*/
diff --git a/src/vt/utils/kokkos/reduce_op.h b/src/vt/utils/kokkos/reduce_op.h
new file mode 100644
index 0000000000..20ede9299c
--- /dev/null
+++ b/src/vt/utils/kokkos/reduce_op.h
@@ -0,0 +1,93 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                                 reduce_op.h
+//                       DARMA/vt => Virtual Transport
+//
+// Copyright 2019-2024 National Technology & Engineering Solutions of Sandia, LLC
+// (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact darma@sandia.gov
+//
+// *****************************************************************************
+//@HEADER
+*/
+
+#if !defined INCLUDED_VT_UTILS_KOKKOS_REDUCE_OP_H
+#define INCLUDED_VT_UTILS_KOKKOS_REDUCE_OP_H
+
+#include "vt/config.h"
+
+#if MAGISTRATE_KOKKOS_ENABLED
+
+#include "vt/collective/reduce/operators/default_op.h"
+
+namespace vt::utils::kokkos {
+
+template <typename Op>
+struct KokkosOp {
+  template <typename T>
+  KOKKOS_INLINE_FUNCTION
+  void operator()(T& v1, T const& v2) {
+    if constexpr (std::is_same_v<
+                    Op, vt::collective::reduce::operators::AndOp<T>>) {
+      v1 = v1 && v2;
+    } else if constexpr (std::is_same_v<
+                           Op,
+                           vt::collective::reduce::operators::BitAndOp<T>>) {
+      v1 = v1 & v2;
+    } else if constexpr (std::is_same_v<
+                           Op, vt::collective::reduce::operators::BitOrOp<T>>) {
+      v1 = v1 | v2;
+    } else if constexpr (std::is_same_v<
+                           Op,
+                           vt::collective::reduce::operators::BitXorOp<T>>) {
+      v1 = v1 ^ v2;
+    } else if constexpr (std::is_same_v<
+                           Op, vt::collective::reduce::operators::MaxOp<T>>) {
+      v1 = std::max(v1, v2);
+    } else if constexpr (std::is_same_v<
+                           Op, vt::collective::reduce::operators::MinOp<T>>) {
+      v1 = std::min(v1, v2);
+    } else if constexpr (std::is_same_v<
+                           Op, vt::collective::reduce::operators::OrOp<T>>) {
+      v1 = v1 || v2;
+    } else if constexpr (std::is_same_v<
+                           Op, vt::collective::reduce::operators::PlusOp<T>>) {
+      v1 = v1 + v2;
+    }
+  }
+};
+
+} // namespace vt::utils::kokkos
+
+#endif // MAGISTRATE_KOKKOS_ENABLED
+#endif /*INCLUDED_VT_UTILS_KOKKOS_REDUCE_OP_H*/
diff --git a/src/vt/vrt/collection/dispatch/dispatch.h b/src/vt/vrt/collection/dispatch/dispatch.h
index 232c5ebdbb..13ceee0298 100644
--- a/src/vt/vrt/collection/dispatch/dispatch.h
+++ b/src/vt/vrt/collection/dispatch/dispatch.h
@@ -63,6 +63,8 @@ struct DispatchCollectionBase {
   virtual void
   broadcast(VirtualProxyType proxy, std::byte* msg, HandlerType han) = 0;
   virtual void
+  broadcastCollective(VirtualProxyType proxy, std::byte* msg, HandlerType han) = 0;
+  virtual void
   send(VirtualProxyType proxy, std::byte* idx, std::byte* msg, HandlerType han) = 0;
 
   template <typename=void>
@@ -84,6 +86,7 @@ template <typename ColT, typename MsgT>
 struct DispatchCollection final : DispatchCollectionBase {
 private:
   void broadcast(VirtualProxyType proxy, std::byte* msg, HandlerType han) override;
+  void broadcastCollective(VirtualProxyType proxy, std::byte* msg, HandlerType han) override;
   void send(
     VirtualProxyType proxy, std::byte* idx, std::byte* msg, HandlerType han
   ) override;
diff --git a/src/vt/vrt/collection/dispatch/dispatch.impl.h b/src/vt/vrt/collection/dispatch/dispatch.impl.h
index e6ba080e51..5d4bdc2f09 100644
--- a/src/vt/vrt/collection/dispatch/dispatch.impl.h
+++ b/src/vt/vrt/collection/dispatch/dispatch.impl.h
@@ -66,6 +66,18 @@ void DispatchCollection<ColT, MsgT>::broadcast(
   );
 }
 
+template <typename ColT, typename MsgT>
+void DispatchCollection<ColT, MsgT>::broadcastCollective(
+  VirtualProxyType proxy, std::byte* msg, HandlerType han
+) {
+  using IdxT = typename ColT::IndexType;
+  auto const msg_typed = reinterpret_cast<MsgT*>(msg);
+  CollectionProxy<ColT, IdxT> typed_proxy{proxy};
+  theCollection()->broadcastCollectiveMsgWithHan<MsgT, ColT>(
+    typed_proxy, msg_typed, han, true
+  );
+}
+
 template <typename ColT, typename MsgT>
 void DispatchCollection<ColT, MsgT>::send(
   VirtualProxyType proxy, std::byte* idx, std::byte* msg, HandlerType han
diff --git a/src/vt/vrt/collection/holders/typeless_holder.cc b/src/vt/vrt/collection/holders/typeless_holder.cc
index de07ab81c6..82569ae122 100644
--- a/src/vt/vrt/collection/holders/typeless_holder.cc
+++ b/src/vt/vrt/collection/holders/typeless_holder.cc
@@ -43,6 +43,8 @@
 
 #include "vt/vrt/collection/holders/typeless_holder.h"
 #include "vt/scheduler/scheduler.h"
+#include "vt/collective/reduce/allreduce/state_holder.h"
+#include "vt/collective/reduce/allreduce/allreduce_holder.h"
 
 namespace vt { namespace vrt { namespace collection {
 
@@ -73,6 +75,10 @@ void TypelessHolder::destroyCollection(VirtualProxyType const proxy) {
       labels_.erase(iter);
     }
   }
+
+  vt::collective::reduce::allreduce::AllreduceHolder::remove(
+    vt::collective::reduce::detail::StrongVrtProxy{proxy}
+  );
 }
 
 void TypelessHolder::invokeAllGroupConstructors() {
diff --git a/src/vt/vrt/collection/manager.h b/src/vt/vrt/collection/manager.h
index ccbebb8ab2..9df0557562 100644
--- a/src/vt/vrt/collection/manager.h
+++ b/src/vt/vrt/collection/manager.h
@@ -743,6 +743,12 @@ struct CollectionManager
     bool instrument
   );
 
+
+  template <typename ReducerT, auto f, typename ColT, template <typename Arg> class Op, typename ...Args>
+  messaging::PendingSend reduceLocal(
+    CollectionProxyWrapType<ColT> const& proxy, Args &&... args
+  );
+
   /**
    * \brief Reduce over a collection
    *
@@ -885,6 +891,27 @@ struct CollectionManager
     HandlerType const handler, bool instrument
   );
 
+  /**
+   * \internal \brief Broadcast to collection with a collection message
+   *
+   * \param[in] proxy the collection proxy
+   * \param[in] msg the message
+   * \param[in] handler the handler to invoke
+   * \param[in] instrument whether to instrument the broadcast for load
+   * balancing (some system calls use this to disable instrumentation)
+   */
+  template <typename MsgT, typename ColT>
+  IsNotColMsgType<MsgT> broadcastCollectiveMsgWithHan(
+    CollectionProxyWrapType<ColT> const& proxy, MsgT* msg,
+    HandlerType const handler, bool instrument = true
+  );
+
+  template <typename MsgT, typename ColT>
+  IsColMsgType<MsgT> broadcastCollectiveMsgWithHan(
+    CollectionProxyWrapType<ColT> const& proxy, MsgT* msg,
+    HandlerType const handler, bool instrument = true
+  );
+
   /**
    * \brief Broadcast collective a message with action function handler
    * \note Takes ownership of the supplied message
@@ -1766,6 +1793,10 @@ struct CollectionManager
   VirtualIDType next_rooted_id_ = 0;
   TypelessHolder typeless_holder_;
   std::unordered_map<VirtualProxyType, SequentialIDType> reduce_stamp_;
+
+  // Allreduce stuff, probably should be moved elsewhere
+  std::unordered_map<VirtualProxyType, ObjGroupProxyType> rabenseifner_reducers_;
+  std::unordered_map<VirtualProxyType, ObjGroupProxyType> recursive_doubling_reducers_;
 };
 
 }}} /* end namespace vt::vrt::collection */
diff --git a/src/vt/vrt/collection/manager.impl.h b/src/vt/vrt/collection/manager.impl.h
index f03d60fa9f..7ea7828064 100644
--- a/src/vt/vrt/collection/manager.impl.h
+++ b/src/vt/vrt/collection/manager.impl.h
@@ -79,6 +79,7 @@
 #include "vt/scheduler/scheduler.h"
 #include "vt/phase/phase_manager.h"
 #include "vt/runnable/make_runnable.h"
+#include "vt/collective/reduce/allreduce/allreduce_holder.h"
 
 #include <tuple>
 #include <utility>
@@ -639,6 +640,29 @@ messaging::PendingSend CollectionManager::broadcastFromRoot(MsgT* raw_msg) {
   return ret;
 }
 
+template <typename MsgT, typename ColT>
+CollectionManager::IsNotColMsgType<MsgT>
+CollectionManager::broadcastCollectiveMsgWithHan(
+  CollectionProxyWrapType<ColT> const& proxy, MsgT* msg, HandlerType const han,
+  bool instrument) {
+  auto wrap_msg = makeMessage<ColMsgWrap<ColT, MsgT>>(std::move(*msg));
+  wrap_msg->setVrtHandler(han);
+
+  return broadcastCollectiveMsgImpl<ColMsgWrap<ColT, MsgT>, ColT>(proxy, wrap_msg, instrument);
+}
+
+template <typename MsgT, typename ColT>
+CollectionManager::IsColMsgType<MsgT>
+CollectionManager::broadcastCollectiveMsgWithHan(
+  CollectionProxyWrapType<ColT> const& proxy, MsgT* msg, HandlerType const han,
+  bool instrument) {
+
+  auto msgPtr = promoteMsg(msg);
+  msgPtr->setVrtHandler(han);
+
+  return broadcastCollectiveMsgImpl<MsgT, ColT>(proxy, msgPtr, instrument);
+}
+
 template <
   typename MsgT, ActiveColTypedFnType<MsgT, typename MsgT::CollectionType>* f
 >
@@ -870,6 +894,41 @@ messaging::PendingSend CollectionManager::broadcastMsgUntypedHandler(
   }
 }
 
+template <
+  typename ReducerT, auto f, typename ColT, template <typename Arg> class Op,
+  typename... Args>
+messaging::PendingSend CollectionManager::reduceLocal(
+  CollectionProxyWrapType<ColT> const& proxy, Args&&... args) {
+  using namespace collective::reduce::allreduce;
+
+  using DataT =
+    std::tuple_element_t<0, typename FuncTraits<decltype(f)>::TupleType>;
+  using IndexT = typename ColT::IndexType;
+
+  // Get the current running index context
+  IndexT idx = *queryIndexContext<IndexT>();
+  auto const col_proxy = proxy.getProxy();
+
+  auto elm_holder = findElmHolder<IndexT>(col_proxy);
+  std::size_t num_elms = elm_holder->numElements();
+  auto const group = elm_holder->group();
+
+  auto stamp = proxy(idx).tryGetLocalPtr()->getNextAllreduceStamp();
+  auto const id = std::get<collective::reduce::detail::StrongSeq>(stamp).get();
+
+  auto cb = vt::theCB()->makeCallbackBcastCollectiveProxy<f>(proxy);
+
+  auto* reducer = AllreduceHolder::getOrCreateAllreducer<ReducerT>(
+    collective::reduce::detail::StrongVrtProxy{col_proxy},
+    collective::reduce::detail::StrongGroup{group}, num_elms);
+
+  reducer->template setFinalHandler<DataT>(cb, id);
+  reducer->template storeData<DataT, Op>(id, std::forward<Args>(args)...);
+
+  return messaging::PendingSend{
+    theTerm()->getEpoch(), [reducer, id] { reducer->template run<DataT, Op>(id); }};
+}
+
 template <typename ColT, typename MsgT, ActiveTypedFnType<MsgT> *f>
 messaging::PendingSend CollectionManager::reduceMsgExpr(
   CollectionProxyWrapType<ColT> const& proxy,
@@ -926,6 +985,11 @@ messaging::PendingSend CollectionManager::reduceMsgExpr(
     cur_stamp = proxy(idx).tryGetLocalPtr()->getNextStamp();
   }
 
+  vt_debug_print(
+    terse, allreduce,
+    "reduceMsg: col_proxy={:x}, num_elms={}, send_group={}, use_group={} group={:x}\n",
+    col_proxy, num_elms, send_group, use_group, group
+  );
   collective::reduce::Reduce* r = nullptr;
   if (use_group) {
     r = theGroup()->groupReducer(group);
diff --git a/src/vt/vrt/collection/reducable/reducable.h b/src/vt/vrt/collection/reducable/reducable.h
index 707aedfa02..65b46c8908 100644
--- a/src/vt/vrt/collection/reducable/reducable.h
+++ b/src/vt/vrt/collection/reducable/reducable.h
@@ -85,6 +85,16 @@ struct Reducable : BaseProxyT {
     Args&&... args
   ) const;
 
+  template <
+    typename ReducerT,
+    auto f,
+    template <typename Arg> class Op = collective::NoneOp,
+    typename... Args
+  >
+  messaging::PendingSend allreduce(
+    Args&&... args
+  ) const;
+
   /**
    * \brief Reduce back to a point target. Performs a reduction using operator
    * `Op` followed by a send to `f` with the result.
diff --git a/src/vt/vrt/collection/reducable/reducable.impl.h b/src/vt/vrt/collection/reducable/reducable.impl.h
index 399ba68c89..5c622978fa 100644
--- a/src/vt/vrt/collection/reducable/reducable.impl.h
+++ b/src/vt/vrt/collection/reducable/reducable.impl.h
@@ -80,6 +80,16 @@ messaging::PendingSend Reducable<ColT,IndexT,BaseProxyT>::allreduce(
   >(proxy, msg.get(), stamp, root_node);
 }
 
+template <typename ColT, typename IndexT, typename BaseProxyT>
+template <typename ReducerT, auto f, template <typename Arg> class Op, typename... Args>
+messaging::PendingSend Reducable<ColT,IndexT,BaseProxyT>::allreduce(
+  Args&&... args
+) const {
+  auto const proxy = this->getProxy();
+  return theCollection()->reduceLocal<ReducerT, f, ColT, Op>(
+    proxy, std::forward<Args>(args)...);
+}
+
 template <typename ColT, typename IndexT, typename BaseProxyT>
 template <auto f, template <typename Arg> class Op, typename Target, typename... Args>
 messaging::PendingSend Reducable<ColT,IndexT,BaseProxyT>::reduce(
diff --git a/src/vt/vrt/collection/types/indexable.h b/src/vt/vrt/collection/types/indexable.h
index ed5660bfcb..96194e083e 100644
--- a/src/vt/vrt/collection/types/indexable.h
+++ b/src/vt/vrt/collection/types/indexable.h
@@ -90,6 +90,13 @@ struct Indexable : Migratable {
    */
   ReduceStampType getNextStamp();
 
+  /**
+   * \brief Get the next allreduce stamp and increment
+   *
+   * \return the reduce stamp
+   */
+  ReduceStampType getNextAllreduceStamp();
+
   /**
    * \brief Zero out the reduce stamp
    */
@@ -97,6 +104,7 @@ struct Indexable : Migratable {
 
 protected:
   ReduceSeqStampType reduce_stamp_ = ReduceSeqStampType{1};
+  ReduceSeqStampType allreduce_stamp_ = ReduceSeqStampType{0};
 };
 
 }}} /* end namespace vt::vrt::collection */
diff --git a/src/vt/vrt/collection/types/indexable.impl.h b/src/vt/vrt/collection/types/indexable.impl.h
index 8941516bbe..9024f353e2 100644
--- a/src/vt/vrt/collection/types/indexable.impl.h
+++ b/src/vt/vrt/collection/types/indexable.impl.h
@@ -103,6 +103,14 @@ typename Indexable<IndexT>::ReduceStampType Indexable<IndexT>::getNextStamp() {
   return stamp;
 }
 
+template <typename IndexT>
+typename Indexable<IndexT>::ReduceStampType Indexable<IndexT>::getNextAllreduceStamp() {
+  ReduceStampType stamp;
+  stamp = ReduceSeqStampType{allreduce_stamp_};
+  *allreduce_stamp_ = *allreduce_stamp_ + 1;
+  return stamp;
+}
+
 }}} /* end namespace vt::vrt::collection */
 
 #endif /*INCLUDED_VT_VRT_COLLECTION_TYPES_INDEXABLE_IMPL_H*/
diff --git a/tests/perf/allreduce.cc b/tests/perf/allreduce.cc
new file mode 100644
index 0000000000..930ae0358a
--- /dev/null
+++ b/tests/perf/allreduce.cc
@@ -0,0 +1,419 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                                 allreduce.cc
+//                       DARMA/vt => Virtual Transport
+//
+// Copyright 2019-2021 National Technology & Engineering Solutions of Sandia, LLC
+// (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact darma@sandia.gov
+//
+// *****************************************************************************
+//@HEADER
+*/
+
+#include "common/test_harness.h"
+#include "vt/collective/collective_alg.h"
+#include "vt/collective/reduce/allreduce/type.h"
+#include "vt/collective/reduce/operators/functors/max_op.h"
+#include "vt/collective/reduce/operators/functors/plus_op.h"
+#include "vt/configs/error/config_assert.h"
+#include "vt/configs/types/types_type.h"
+#include "vt/context/context.h"
+#include "vt/group/group_manager.h"
+#include "vt/scheduler/scheduler.h"
+#include <unordered_map>
+#include <vt/collective/collective_ops.h>
+#include <vt/objgroup/manager.h>
+#include <vt/messaging/active.h>
+#include <vt/collective/reduce/allreduce/rabenseifner.h>
+#include <vt/collective/reduce/allreduce/recursive_doubling.h>
+#include <vt/vrt/collection/manager.h>
+#include <vt/collective/reduce/allreduce/state_holder.h>
+
+#ifdef MAGISTRATE_KOKKOS_ENABLED
+#include <Kokkos_Core.hpp>
+#endif
+
+using namespace vt;
+using namespace vt::tests::perf::common;
+
+static constexpr std::array<size_t, 9> const payloadSizes = {
+  64, 128, 2048, 16384, 32768, 524288, 1048576, 2097152, 4194304};
+
+struct MyTest : PerfTestHarness {
+  MyTest() {
+    DisableGlobalTimer();
+    data.reserve(*std::max_element(payloadSizes.begin(), payloadSizes.end()));
+  }
+
+  std::vector<int32_t> data;
+};
+
+template <typename TestT>
+struct NodeObj {
+  explicit NodeObj(TestT* test_obj, const std::string& name)
+    : base_name_(name),
+      test_obj_(test_obj) {
+    for (auto const payload_size : payloadSizes) {
+      timer_names_[payload_size] =
+        fmt::format("{} {}", base_name_, payload_size);
+    }
+  }
+
+  void initialize() { proxy_ = vt::theObjGroup()->getProxy<NodeObj>(this); }
+
+  void handlerVec(const std::vector<int32_t>& vec) {
+    test_obj_->StopTimer(timer_names_.at(vec.size()));
+    allreduce_done_ = true;
+  }
+
+#if MAGISTRATE_KOKKOS_ENABLED
+  template <typename Scalar>
+  void handlerView(Kokkos::View<Scalar*, Kokkos::HostSpace> view) {
+    test_obj_->StopTimer(timer_names_.at(view.extent(0)));
+    allreduce_done_ = true;
+  }
+#endif // MAGISTRATE_KOKKOS_ENABLED
+
+  std::string base_name_ = {};
+  std::unordered_map<size_t, std::string> timer_names_ = {};
+  TestT* test_obj_ = nullptr;
+  vt::objgroup::proxy::Proxy<NodeObj> proxy_ = {};
+  bool allreduce_done_ = false;
+};
+
+VT_PERF_TEST(MyTest, test_mpi_allreduce) {
+    for (auto payload_size : payloadSizes) {
+        data.resize(payload_size, theContext()->getNode() + 1);
+        std::vector<int> result(payload_size);
+        MPI_Barrier(MPI_COMM_WORLD);
+        StartTimer("MPI_Allreduce vector " + std::to_string(payload_size));
+        MPI_Allreduce(data.data(), result.data(), payload_size, MPI_INT, MPI_SUM, MPI_COMM_WORLD);
+        StopTimer("MPI_Allreduce vector " + std::to_string(payload_size));
+    }
+}
+
+VT_PERF_TEST(MyTest, test_reduce) {
+  auto grp_proxy = vt::theObjGroup()->makeCollective<NodeObj<MyTest>>(
+    "test_allreduce", this, "Reduce -> Bcast vector");
+
+  for (auto payload_size : payloadSizes) {
+    data.resize(payload_size, theContext()->getNode() + 1);
+
+    theCollective()->barrier();
+    auto* obj_ptr = grp_proxy[my_node_].get();
+    StartTimer(obj_ptr->timer_names_.at(payload_size));
+    grp_proxy.allreduce<&NodeObj<MyTest>::handlerVec, collective::PlusOp>(data);
+
+    theSched()->runSchedulerWhile(
+      [obj_ptr] { return !obj_ptr->allreduce_done_; });
+    obj_ptr->allreduce_done_ = false;
+  }
+}
+
+#if MAGISTRATE_KOKKOS_ENABLED
+
+struct MyTestKokkos : PerfTestHarness {
+  MyTestKokkos() { DisableGlobalTimer(); }
+
+  Kokkos::View<float*, Kokkos::HostSpace> view;
+};
+
+VT_PERF_TEST(MyTestKokkos, test_mpi_allreduce_kokkos) {
+    for (auto payload_size : payloadSizes) {
+        view = Kokkos::View<float*, Kokkos::HostSpace>("view", payload_size);
+        auto result = Kokkos::View<float*, Kokkos::HostSpace>("result", payload_size);
+        MPI_Barrier(MPI_COMM_WORLD);
+        StartTimer("MPI_Allreduce view " + std::to_string(payload_size));
+        MPI_Allreduce(view.data(), result.data(), payload_size, MPI_FLOAT, MPI_SUM, MPI_COMM_WORLD);
+        StopTimer("MPI_Allreduce view " + std::to_string(payload_size));
+    }
+}
+
+VT_PERF_TEST(MyTestKokkos, test_reduce_kokkos) {
+  auto grp_proxy = vt::theObjGroup()->makeCollective<NodeObj<MyTestKokkos>>(
+    "test_allreduce", this, "Reduce -> Bcast view");
+
+  for (auto payload_size : payloadSizes) {
+    view = Kokkos::View<float*, Kokkos::HostSpace>("view", payload_size);
+    for (uint32_t i = 0; i < view.extent(0); ++i) {
+      view(i) = static_cast<float>(my_node_);
+    }
+
+    theCollective()->barrier();
+    auto* obj_ptr = grp_proxy[my_node_].get();
+    StartTimer(obj_ptr->timer_names_.at(payload_size));
+
+    grp_proxy.allreduce<
+      &NodeObj<MyTestKokkos>::handlerView<float>, collective::PlusOp>(view);
+
+    theSched()->runSchedulerWhile(
+      [obj_ptr] { return !obj_ptr->allreduce_done_; });
+    obj_ptr->allreduce_done_ = false;
+  }
+}
+#endif
+
+VT_PERF_TEST(MyTest, test_allreduce_rabenseifner) {
+  auto proxy = vt::theObjGroup()->makeCollective<NodeObj<MyTest>>(
+    "test_allreduce_rabenseifner", this, "Rabenseifner vector");
+
+  for (auto payload_size : payloadSizes) {
+    data.resize(payload_size, theContext()->getNode() + 1);
+
+    theCollective()->barrier();
+    auto* obj_ptr = proxy[my_node_].get();
+    StartTimer(obj_ptr->timer_names_.at(payload_size));
+    proxy.allreduce<
+      &NodeObj<MyTest>::handlerVec, collective::PlusOp,
+      vt::collective::reduce::allreduce::RabenseifnerT>(data);
+
+    theSched()->runSchedulerWhile(
+      [obj_ptr] { return !obj_ptr->allreduce_done_; });
+    obj_ptr->allreduce_done_ = false;
+  }
+}
+
+#if MAGISTRATE_KOKKOS_ENABLED
+VT_PERF_TEST(MyTestKokkos, test_allreduce_rabenseifner_kokkos) {
+  auto proxy = vt::theObjGroup()->makeCollective<NodeObj<MyTestKokkos>>(
+    "test_allreduce_rabenseifner", this, "Rabenseifner view");
+
+  for (auto payload_size : payloadSizes) {
+    view = Kokkos::View<float*, Kokkos::HostSpace>("view", payload_size);
+
+    theCollective()->barrier();
+    auto* obj_ptr = proxy[my_node_].get();
+    StartTimer(obj_ptr->timer_names_.at(payload_size));
+
+    proxy.allreduce<
+      &NodeObj<MyTestKokkos>::handlerView<float>, collective::PlusOp,
+      vt::collective::reduce::allreduce::RabenseifnerT>(view);
+
+    theSched()->runSchedulerWhile(
+      [obj_ptr] { return !obj_ptr->allreduce_done_; });
+    obj_ptr->allreduce_done_ = false;
+  }
+}
+#endif // MAGISTRATE_KOKKOS_ENABLED
+
+VT_PERF_TEST(MyTest, test_allreduce_recursive_doubling) {
+  auto proxy = vt::theObjGroup()->makeCollective<NodeObj<MyTest>>(
+    "test_allreduce_recursive_doubling", this, "Recursive doubling vector");
+
+  for (auto payload_size : payloadSizes) {
+    data.resize(payload_size, theContext()->getNode() + 1);
+
+    theCollective()->barrier();
+    auto* obj_ptr = proxy[my_node_].get();
+    StartTimer(obj_ptr->timer_names_.at(payload_size));
+
+    proxy.allreduce<
+      &NodeObj<MyTest>::handlerVec, collective::PlusOp,
+      vt::collective::reduce::allreduce::RecursiveDoublingT>(data);
+
+    theSched()->runSchedulerWhile(
+      [obj_ptr] { return !obj_ptr->allreduce_done_; });
+    obj_ptr->allreduce_done_ = false;
+  }
+}
+
+#if MAGISTRATE_KOKKOS_ENABLED
+VT_PERF_TEST(MyTestKokkos, test_allreduce_recursive_doubling_kokkos) {
+  auto proxy = vt::theObjGroup()->makeCollective<NodeObj<MyTestKokkos>>(
+    "test_allreduce_rabenseifner", this, "Recursive doubling view");
+
+  for (auto payload_size : payloadSizes) {
+    view = Kokkos::View<float*, Kokkos::HostSpace>("view", payload_size);
+
+    theCollective()->barrier();
+    auto* obj_ptr = proxy[my_node_].get();
+    StartTimer(obj_ptr->timer_names_.at(payload_size));
+
+    proxy.allreduce<
+      &NodeObj<MyTestKokkos>::handlerView<float>, collective::PlusOp,
+      vt::collective::reduce::allreduce::RecursiveDoublingT>(view);
+
+    theSched()->runSchedulerWhile(
+      [obj_ptr] { return !obj_ptr->allreduce_done_; });
+    obj_ptr->allreduce_done_ = false;
+  }
+}
+#endif // MAGISTRATE_KOKKOS_ENABLED
+
+namespace test_group {
+bool group_allreduce_done = false;
+std::unordered_map<size_t, std::string> timer_names = {};
+MyTest* parent = {};
+} // namespace test_group
+
+void allreduce_group_han(std::vector<int32_t> result) {
+  test_group::parent->StopTimer(test_group::timer_names.at(result.size()));
+  test_group::group_allreduce_done = true;
+}
+
+VT_PERF_TEST(MyTest, test_allreduce_group_rabenseifner) {
+  for (auto const payload_size : payloadSizes) {
+    test_group::timer_names[payload_size] =
+      fmt::format("Group vector {}", payload_size);
+  }
+  test_group::parent = this;
+  bool group_ready = false;
+  auto const is_odd = my_node_ % 2 == 1;
+
+  auto g = vt::theGroup()->newGroupCollective(
+    is_odd, [&](GroupType) { group_ready = true; });
+  theSched()->runSchedulerWhile([&] { return !group_ready; });
+
+  for (auto payload_size : payloadSizes) {
+    std::vector<int32_t> payload(payload_size, theContext()->getNode());
+
+    StartTimer(test_group::timer_names.at(payload_size));
+    vt::theGroup()
+      ->allreduce<
+        collective::reduce::allreduce::RabenseifnerT, allreduce_group_han,
+        collective::PlusOp>(g, std::move(payload));
+
+    theSched()->runSchedulerWhile(
+      [is_odd] { return is_odd and !test_group::group_allreduce_done; });
+    test_group::group_allreduce_done = false;
+  }
+}
+
+struct RabensifnerColl : vt::Collection<RabensifnerColl, vt::Index1D> {
+  RabensifnerColl() {
+    for (auto const payload_size : payloadSizes) {
+      timer_names_[payload_size] = fmt::format("Collection Rabenseifner {}", payload_size);
+    }
+  }
+
+  void allreduceHan(std::vector<int32_t> result) {
+    col_send_done_ = true;
+    parent_->StopTimer(timer_names_.at(result.size()));
+  }
+
+  void executeAllreduce(size_t payload_size) {
+    auto proxy = this->getCollectionProxy();
+
+    std::vector<int32_t> payload(payload_size, getIndex().x());
+    parent_->StartTimer(timer_names_.at(payload_size));
+    proxy.allreduce<
+      collective::reduce::allreduce::RabenseifnerT, &RabensifnerColl::allreduceHan,
+      collective::PlusOp
+    >(payload);
+  }
+
+  bool col_send_done_ = false;
+  std::unordered_map<size_t, std::string> timer_names_ = {};
+  MyTest* parent_ = {};
+};
+
+VT_PERF_TEST(MyTest, test_allreduce_collection_rabenseifner) {
+  auto const num_elms_per_node = 1;
+  auto range = vt::Index1D(int32_t{num_nodes_ * num_elms_per_node});
+  auto proxy = vt::makeCollection<RabensifnerColl>("test_collection_allreduce")
+                 .bounds(range)
+                 .bulkInsert()
+                 .wait();
+
+  auto const thisNode = vt::theContext()->getNode();
+
+  theCollective()->barrier();
+
+  auto const elm = thisNode * num_elms_per_node;
+  proxy[elm].tryGetLocalPtr()->parent_ = this;
+
+  for (auto payload_size : payloadSizes) {
+    proxy.broadcastCollective<&RabensifnerColl::executeAllreduce>(payload_size);
+
+    // We run 1 coll elem per node, so it should be ok
+    theSched()->runSchedulerWhile(
+      [&] { return !proxy[elm].tryGetLocalPtr()->col_send_done_; });
+    proxy[elm].tryGetLocalPtr()->col_send_done_ = false;
+  }
+}
+
+struct RecursiveDoublingColl : vt::Collection<RecursiveDoublingColl, vt::Index1D> {
+  RecursiveDoublingColl() {
+    for (auto const payload_size : payloadSizes) {
+      timer_names_[payload_size] = fmt::format("Collection RecursiveDoubling {}", payload_size);
+    }
+  }
+
+  void allreduceHan(std::vector<int32_t> result) {
+    col_send_done_ = true;
+    parent_->StopTimer(timer_names_.at(result.size()));
+  }
+
+  void executeAllreduce(size_t payload_size) {
+    auto proxy = this->getCollectionProxy();
+
+    std::vector<int32_t> payload(payload_size, getIndex().x());
+    parent_->StartTimer(timer_names_.at(payload_size));
+    proxy.allreduce<
+      collective::reduce::allreduce::RecursiveDoublingT, &RecursiveDoublingColl::allreduceHan,
+      collective::PlusOp
+    >(payload);
+  }
+
+  bool col_send_done_ = false;
+  std::unordered_map<size_t, std::string> timer_names_ = {};
+  MyTest* parent_ = {};
+};
+
+VT_PERF_TEST(MyTest, test_allreduce_collection_racursive_doubling) {
+  auto const num_elms_per_node = 1;
+  auto range = vt::Index1D(int32_t{num_nodes_ * num_elms_per_node});
+  auto proxy = vt::makeCollection<RecursiveDoublingColl>("test_collection_allreduce")
+                 .bounds(range)
+                 .bulkInsert()
+                 .wait();
+
+  auto const thisNode = vt::theContext()->getNode();
+
+  theCollective()->barrier();
+
+  auto const elm = thisNode * num_elms_per_node;
+  proxy[elm].tryGetLocalPtr()->parent_ = this;
+
+  for (auto payload_size : payloadSizes) {
+    proxy.broadcastCollective<&RecursiveDoublingColl::executeAllreduce>(payload_size);
+
+    // We run 1 coll elem per node, so it should be ok
+    theSched()->runSchedulerWhile(
+      [&] { return !proxy[elm].tryGetLocalPtr()->col_send_done_; });
+    proxy[elm].tryGetLocalPtr()->col_send_done_ = false;
+  }
+}
+
+VT_PERF_TEST_MAIN()
diff --git a/tests/perf/common/test_harness_macros.h b/tests/perf/common/test_harness_macros.h
index 3b35f1eca0..3a369642b8 100644
--- a/tests/perf/common/test_harness_macros.h
+++ b/tests/perf/common/test_harness_macros.h
@@ -46,6 +46,10 @@
 
 #include "test_harness_base.h"
 
+#if MAGISTRATE_KOKKOS_ENABLED
+#include "Kokkos_Core.hpp"
+#endif // MAGISTRATE_KOKKOS_ENABLED
+
 #include <vector>
 #include <memory>
 
@@ -69,14 +73,12 @@ namespace vt { namespace tests { namespace perf { namespace common {
   *
   * VT_PERF_TEST_MAIN()
   */
-
-
 struct PerfTestRegistry{
   static void AddTest(std::unique_ptr<TestHarnessBase>&& test) {
     tests_.push_back(std::move(test));
   }
 
-  static const std::vector<std::unique_ptr<TestHarnessBase>>&
+  static std::vector<std::unique_ptr<TestHarnessBase>>&
   GetTests() {
     return tests_;
   }
@@ -106,10 +108,23 @@ struct PerfTestRegistry{
   } StructName##TestName##_registerer;                                     \
   void StructName##TestName::TestFunc()
 
+inline void tryInitializeKokkos() {
+#if MAGISTRATE_KOKKOS_ENABLED
+  Kokkos::initialize();
+#endif // MAGISTRATE_KOKKOS_ENABLED
+}
+
+inline void tryFinalizeKokkos() {
+#if MAGISTRATE_KOKKOS_ENABLED
+  Kokkos::finalize();
+#endif // MAGISTRATE_KOKKOS_ENABLED
+}
+
 #define VT_PERF_TEST_MAIN()                                                  \
   int main(int argc, char** argv) {                                          \
     using namespace vt::tests::perf::common;                                 \
     MPI_Init(&argc, &argv);                                                  \
+    tryInitializeKokkos();                                                   \
     int rank;                                                                \
     MPI_Comm_rank(MPI_COMM_WORLD, &rank);                                    \
     auto& tests = PerfTestRegistry::GetTests();                              \
@@ -144,6 +159,8 @@ struct PerfTestRegistry{
       }                                                                      \
       test->DumpResults();                                                   \
     }                                                                        \
+    tests.clear();                                                           \
+    tryFinalizeKokkos();                                                     \
     MPI_Finalize();                                                          \
     return 0;                                                                \
   }
diff --git a/tests/perf/send_cost.cc b/tests/perf/send_cost.cc
index 3156d1a057..632f1e9d70 100644
--- a/tests/perf/send_cost.cc
+++ b/tests/perf/send_cost.cc
@@ -163,6 +163,7 @@ VT_PERF_TEST(SendTest, test_objgroup_send) {
   grp_proxy[my_node_].invoke<&NodeObj::initialize>();
 
   auto const thisNode = vt::theContext()->getNode();
+  auto const lastNode = theContext()->getNumNodes() - 1;
   auto const nextNode = (thisNode + 1) % num_nodes_;
 
   for (auto size : payloadSizes) {
diff --git a/tests/unit/collection/test_allreduce_collection.cc b/tests/unit/collection/test_allreduce_collection.cc
new file mode 100644
index 0000000000..429ad3117d
--- /dev/null
+++ b/tests/unit/collection/test_allreduce_collection.cc
@@ -0,0 +1,172 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                         test_allreduce_collection.cc
+//                       DARMA/vt => Virtual Transport
+//
+// Copyright 2019-2021 National Technology & Engineering Solutions of Sandia, LLC
+// (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact darma@sandia.gov
+//
+// *****************************************************************************
+//@HEADER
+*/
+
+
+#include "test_parallel_harness.h"
+#include "vt/collective/reduce/allreduce/type.h"
+#include "vt/collective/reduce/operators/functors/max_op.h"
+#include "vt/scheduler/scheduler.h"
+#include "vt/vrt/collection/manager.h"
+#include "vt/topos/index/index.h"
+#include <algorithm>
+#include <fmt-vt/core.h>
+#include <gtest/gtest.h>
+
+namespace vt { namespace tests { namespace unit {
+
+struct RecursiveDoublingColl : vt::Collection<RecursiveDoublingColl, vt::Index1D> {
+  template <size_t size, int32_t num_elms_per_node>
+  void sumAllreduceHan(std::vector<int32_t> result) {
+    ++counter_;
+
+    ASSERT_EQ(result.size(), size);
+
+    auto const num_nodes = theContext()->getNumNodes();
+    auto const num_elems = num_nodes * num_elms_per_node;
+    auto const expected_val = ((num_elems - 1) * num_elems) / 2;
+
+    auto verify_result =
+      std::all_of(result.begin(), result.end(), [=](auto const& val) {
+        return val == expected_val;
+      });
+
+
+    ASSERT_TRUE(verify_result);
+  }
+
+  template <size_t size, int32_t num_elms_per_node>
+  void maxAllreduceHan(std::vector<int32_t> result) {
+    ++counter_;
+
+    ASSERT_EQ(result.size(), size);
+
+    auto const num_nodes = theContext()->getNumNodes();
+    auto const expected_val = (num_nodes * num_elms_per_node) - 1;
+
+    auto verify_result = std::all_of(result.begin(), result.end(), [=](auto const& val) {
+      return val == expected_val;
+    });
+
+    ASSERT_TRUE(verify_result);
+  }
+
+  template <typename ReducerT, size_t size, int32_t num_elms_per_node>
+  void executePlusAllreduce() {
+    using namespace collective::reduce::allreduce;
+    auto proxy = this->getCollectionProxy();
+
+    std::vector<int32_t> payload(size, getIndex().x());
+    proxy.allreduce<
+      ReducerT, &RecursiveDoublingColl::sumAllreduceHan<size, num_elms_per_node>,
+      collective::PlusOp
+    >(payload);
+  }
+
+  template <typename ReducerT, size_t size, int32_t num_elms_per_node>
+  void executeMaxAllreduce() {
+    using namespace collective::reduce::allreduce;
+    auto proxy = this->getCollectionProxy();
+
+    std::vector<int32_t> payload(size, getIndex().x());
+    proxy.allreduce<
+      ReducerT, &RecursiveDoublingColl::maxAllreduceHan<size, num_elms_per_node>,
+      collective::MaxOp
+    >(payload);
+  }
+
+  int32_t counter_ = 0;
+};
+
+struct TestAllreduceCollection : TestParallelHarness {};
+
+TEST_F(TestAllreduceCollection, test_allreduce) {
+  using namespace vt::collective::reduce::allreduce;
+
+  auto const my_node = theContext()->getNode();
+  auto const num_nodes = theContext()->getNumNodes();
+
+  constexpr auto num_elms_per_node = 3;
+  auto range = vt::Index1D(int32_t{num_nodes * num_elms_per_node});
+  auto proxy = vt::makeCollection<RecursiveDoublingColl>("test_collection_allreduce")
+                 .bounds(range)
+                 .bulkInsert()
+                 .wait();
+
+  constexpr size_t size = 100;
+  auto const elm = my_node * num_elms_per_node;
+  auto const& counter = proxy[elm].tryGetLocalPtr()->counter_;
+
+  vt::runInEpochCollective([=] {
+    proxy.broadcastCollective<
+      &RecursiveDoublingColl::executePlusAllreduce<RecursiveDoublingT, size, num_elms_per_node>
+    >();
+  });
+
+  ASSERT_EQ(counter, 1);
+
+  vt::runInEpochCollective([=] {
+    proxy.broadcastCollective<
+      &RecursiveDoublingColl::executeMaxAllreduce<RecursiveDoublingT, size, num_elms_per_node>
+    >();
+  });
+
+  ASSERT_EQ(counter, 2);
+
+  vt::runInEpochCollective([=] {
+    proxy.broadcastCollective<
+      &RecursiveDoublingColl::executePlusAllreduce<RabenseifnerT, size, num_elms_per_node>
+    >();
+  });
+
+  ASSERT_EQ(counter, 3);
+
+  vt::runInEpochCollective([=] {
+    proxy.broadcastCollective<
+      &RecursiveDoublingColl::executeMaxAllreduce<RabenseifnerT, size, num_elms_per_node>
+    >();
+  });
+
+  ASSERT_EQ(counter, 4);
+}
+
+}}} // end namespace vt::tests::unit
diff --git a/tests/unit/objgroup/test_objgroup.cc b/tests/unit/objgroup/test_objgroup.cc
index f1cba6e0a9..230e19c418 100644
--- a/tests/unit/objgroup/test_objgroup.cc
+++ b/tests/unit/objgroup/test_objgroup.cc
@@ -43,10 +43,17 @@
 
 #include "test_objgroup_common.h"
 #include "test_helpers.h"
+#include "vt/collective/reduce/allreduce/rabenseifner.h"
+#include "vt/collective/reduce/allreduce/type.h"
+#include "vt/configs/types/types_type.h"
 #include "vt/objgroup/manager.h"
 
 #include <typeinfo>
 
+#ifdef MAGISTRATE_KOKKOS_ENABLED
+#include <Kokkos_Core.hpp>
+#endif
+
 namespace vt { namespace tests { namespace unit {
 
 struct TestObjGroup : TestParallelHarness {
@@ -256,6 +263,117 @@ TEST_F(TestObjGroup, test_proxy_reduce) {
   }
 }
 
+TEST_F(TestObjGroup, test_proxy_allreduce) {
+  using namespace vt::collective;
+
+  auto const my_node = vt::theContext()->getNode();
+
+  TestObjGroup::total_verify_expected_ = 0;
+  auto proxy = vt::theObjGroup()->makeCollective<MyObjA>("test_proxy_allreduce");
+
+  vt::theCollective()->barrier();
+
+  runInEpochCollective([&] {
+    proxy.allreduce<
+      &MyObjA::verifyAllred<1>, PlusOp, reduce::allreduce::RecursiveDoublingT>(
+      int{my_node});
+  });
+
+  EXPECT_EQ(MyObjA::total_verify_expected_, 1);
+
+  runInEpochCollective([&] {
+    proxy.allreduce<
+      &MyObjA::verifyAllred<2>, PlusOp, reduce::allreduce::RecursiveDoublingT>(
+      4);
+  });
+
+  EXPECT_EQ(MyObjA::total_verify_expected_, 2);
+
+  runInEpochCollective([&] {
+    proxy.allreduce<
+      &MyObjA::verifyAllred<3>, MaxOp, reduce::allreduce::RecursiveDoublingT>(
+      int{my_node});
+  });
+
+  EXPECT_EQ(MyObjA::total_verify_expected_, 3);
+  runInEpochCollective([&] {
+    std::vector<int> payload(256, my_node);
+    proxy.allreduce<
+      &MyObjA::verifyAllredVec<int, 256>, PlusOp,
+      reduce::allreduce::RecursiveDoublingT>(payload);
+  });
+
+  EXPECT_EQ(MyObjA::total_verify_expected_, 4);
+
+  runInEpochCollective([&] {
+    std::vector<int> payload(2048, my_node);
+    proxy.allreduce<
+      &MyObjA::verifyAllredVec<int, 2048>, PlusOp, reduce::allreduce::RabenseifnerT>(
+      payload);
+
+    std::vector<short> payload_large(2048 * 2, my_node);
+    proxy.allreduce<
+      &MyObjA::verifyAllredVec<short, 2048 * 2>, PlusOp, reduce::allreduce::RabenseifnerT>(
+      payload_large);
+  });
+
+  EXPECT_EQ(MyObjA::total_verify_expected_, 6);
+
+  runInEpochCollective([&] {
+    std::vector<int> payload(256, my_node);
+    VectorPayload data{payload};
+    proxy.allreduce<
+      &MyObjA::verifyAllredVecPayload<VectorPayload, 256>, PlusOp,
+      reduce::allreduce::RabenseifnerT>(data);
+  });
+
+  EXPECT_EQ(MyObjA::total_verify_expected_, 7);
+}
+
+#if MAGISTRATE_KOKKOS_ENABLED
+struct TestObjGroupKokkos : TestParallelHarness {
+  void SetUp() override {
+    TestParallelHarness::SetUp();
+
+    Kokkos::initialize();
+
+    SET_MIN_NUM_NODES_CONSTRAINT(2);
+  }
+
+  void TearDown() override {
+    TestParallelHarness::TearDown();
+
+    Kokkos::finalize();
+  }
+};
+
+TEST_F(TestObjGroupKokkos, test_proxy_allreduce_kokkos) {
+  using namespace vt::collective;
+
+  MyObjA::total_verify_expected_ = 0;
+  auto const my_node = vt::theContext()->getNode();
+
+  auto kokkos_proxy =
+    vt::theObjGroup()->makeCollective<MyObjA>("test_proxy_reduce_kokkos");
+
+  vt::theCollective()->barrier();
+
+  runInEpochCollective([&] {
+    Kokkos::View<float*, Kokkos::HostSpace> view("view", 256);
+    for (uint32_t i = 0; i < view.extent(0); i++) {
+      view(i) = static_cast<float>(my_node);
+    }
+
+    kokkos_proxy.allreduce<
+      &MyObjA::verifyAllredView<Kokkos::HostSpace>, PlusOp,
+      reduce::allreduce::RabenseifnerT>(view);
+  });
+
+  EXPECT_EQ(MyObjA::total_verify_expected_, 1);
+}
+#endif // MAGISTRATE_KOKKOS_ENABLED
+
+
 TEST_F(TestObjGroup, test_proxy_invoke) {
   auto const& this_node = theContext()->getNode();
 
diff --git a/tests/unit/objgroup/test_objgroup_common.h b/tests/unit/objgroup/test_objgroup_common.h
index 200f4428f3..f6483f0ca9 100644
--- a/tests/unit/objgroup/test_objgroup_common.h
+++ b/tests/unit/objgroup/test_objgroup_common.h
@@ -46,8 +46,11 @@
 
 #include "test_parallel_harness.h"
 #include "vt/collective/reduce/operators/default_msg.h"
+#include "vt/collective/reduce/allreduce/data_handler.h"
+#include "vt/utils/kokkos/exec_space.h"
 
 #include <numeric>
+#include <vector>
 
 namespace vt { namespace tests { namespace unit {
 
@@ -57,6 +60,24 @@ struct MyMsg : vt::Message {
   vt::NodeType from_ = vt::uninitialized_destination;
 };
 
+struct VectorPayload {
+  VectorPayload() = default;
+
+  friend VectorPayload operator+(VectorPayload v1, VectorPayload const& v2) {
+    for (auto&& elm : v2.vec_) {
+      v1.vec_.push_back(elm);
+    }
+    return v1;
+  }
+
+  template <typename SerializerT>
+  void serialize(SerializerT& s) {
+    s | vec_;
+  }
+
+  std::vector<int> vec_;
+};
+
 struct MyObjA {
 
   MyObjA() : id_(++next_id) {}
@@ -97,6 +118,61 @@ struct MyObjA {
     return i;
   }
 
+  static inline int32_t total_verify_expected_ = 0;
+
+  template <int test>
+  void verifyAllred(int value) {
+    auto const n = vt::theContext()->getNumNodes();
+    switch (test) {
+    case 1: EXPECT_EQ(value, n * (n - 1)/2); break;
+    case 2: EXPECT_EQ(value, n * 4); break;
+    case 3: EXPECT_EQ(value, n - 1); break;
+    default: vtAbort("Failure: should not be reached"); break;
+    }
+    total_verify_expected_++;
+  }
+
+  template<typename Scalar, int32_t size>
+  void verifyAllredVec(std::vector<Scalar> const& vec) {
+    auto final_size = vec.size();
+    EXPECT_EQ(final_size, size);
+
+    auto const n = theContext()->getNumNodes();
+    auto const total_sum = n * (n - 1)/2;
+    for(auto val : vec){
+      EXPECT_EQ(val, total_sum);
+    }
+
+    total_verify_expected_++;
+  }
+
+  template <typename DataT, int32_t size>
+  void verifyAllredVecPayload(VectorPayload vec) {
+    verifyAllredVec<typename decltype(DataT::vec_)::value_type, size>(vec.vec_);
+  }
+
+#if MAGISTRATE_KOKKOS_ENABLED
+  template <typename MemorySpace>
+  void verifyAllredView(Kokkos::View<float*, MemorySpace> view) {
+    auto final_size = view.extent(0);
+    EXPECT_EQ(final_size, 256);
+
+    auto n = vt::theContext()->getNumNodes();
+    auto const total_sum = n * (n - 1) / 2;
+
+    // Just in case it's not Host space
+    auto view_host = Kokkos::create_mirror_view(view);
+    Kokkos::deep_copy(view_host, view);
+
+    vtAssert(view_host.extent(0) == 256, "View size is not right");
+    for(uint32_t i = 0; i < view_host.extent(0); ++i){
+      EXPECT_EQ(view_host(i), total_sum);
+    }
+
+    total_verify_expected_++;
+  }
+#endif // MAGISTRATE_KOKKOS_ENABLED
+
   int id_ = -1;
   int recv_ = 0;
   static int next_id;
@@ -136,26 +212,23 @@ struct MyObjB {
   }
 };
 
-struct VectorPayload {
-  VectorPayload() = default;
-
-  friend VectorPayload operator+(VectorPayload v1, VectorPayload const& v2) {
-    for (auto&& elm : v2.vec_) {
-      v1.vec_.push_back(elm);
-    }
-    return v1;
-  }
-
-  template <typename SerializerT>
-  void serialize(SerializerT& s) {
-    s | vec_;
-  }
-
-  std::vector<int> vec_;
-};
-
 /*static*/ int MyObjA::next_id = 0;
 /*static*/ int MyObjB::next_id = 0;
 }}} // end namespace vt::tests::unit
 
+namespace vt::collective::reduce::allreduce {
+template<>
+class DataHandler<tests::unit::VectorPayload> {
+private:
+  using DataT = ::vt::tests::unit::VectorPayload;
+public:
+  using Scalar = typename decltype(DataT::vec_)::value_type;
+
+  static size_t size(const DataT& data) { return data.vec_.size(); }
+  static const std::vector<Scalar>& toVec(const DataT& data) { return data.vec_; }
+  static DataT fromVec(const std::vector<Scalar>& data) { return DataT{data}; }
+};
+
+} // namespace vt::collective::reduce::allreduce
+
 #endif /*INCLUDED_UNIT_OBJGROUP_TEST_OBJGROUP_COMMON_H*/
diff --git a/tests/unit/pipe/test_callback_bcast_collective.cc b/tests/unit/pipe/test_callback_bcast_collective.cc
new file mode 100644
index 0000000000..2d79ce8082
--- /dev/null
+++ b/tests/unit/pipe/test_callback_bcast_collective.cc
@@ -0,0 +1,299 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                      test_callback_bcast_collective.cc
+//                       DARMA/vt => Virtual Transport
+//
+// Copyright 2019-2021 National Technology & Engineering Solutions of Sandia, LLC
+// (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact darma@sandia.gov
+//
+// *****************************************************************************
+//@HEADER
+*/
+
+#include <gtest/gtest.h>
+
+#include "test_parallel_harness.h"
+#include "data_message.h"
+#include "test_helpers.h"
+
+#include "vt/context/context.h"
+#include "vt/vrt/collection/manager.h"
+
+#include <memory>
+
+namespace vt { namespace tests { namespace unit { namespace pipe {
+
+using namespace vt;
+using namespace vt::tests::unit;
+
+struct CallbackMsg : vt::Message {
+  CallbackMsg() = default;
+  explicit CallbackMsg(Callback<> in_cb) : cb_(in_cb) { }
+
+  Callback<> cb_;
+};
+
+struct DataMsg : vt::Message {
+  DataMsg() = default;
+  DataMsg(int in_a, int in_b, int in_c) : a(in_a), b(in_b), c(in_c) { }
+  int a = 0, b = 0, c = 0;
+};
+
+struct CallbackDataMsg : vt::Message {
+  CallbackDataMsg() = default;
+  explicit CallbackDataMsg(Callback<DataMsg> in_cb) : cb_(in_cb) { }
+
+  Callback<DataMsg> cb_;
+};
+
+struct TestCallbackBcastCollective : TestParallelHarness {
+  static void testHandler(CallbackDataMsg* msg) {
+    msg->cb_.send(8,9,10);
+  }
+  static void testHandlerEmpty(CallbackMsg* msg) {
+    msg->cb_.send();
+  }
+};
+
+struct TestCol : vt::Collection<TestCol, vt::Index1D> {
+  TestCol() = default;
+
+  virtual ~TestCol() = default;
+
+  void check1() {
+    if (theContext()->getNode() == 0) {
+      EXPECT_EQ(val, 29);
+    } else {
+      EXPECT_EQ(val, 17);
+    }
+  }
+
+  void check2() {
+    if (theContext()->getNode() == 1) {
+      EXPECT_EQ(val, 13);
+    } else {
+      EXPECT_EQ(val, 17);
+    }
+  }
+
+  void check3() {
+    if (theContext()->getNode() == 0) {
+      EXPECT_EQ(val, 15);
+    } else {
+      EXPECT_EQ(val, 17);
+    }
+  }
+
+  void check4() {
+    if (theContext()->getNode() == 0) {
+      EXPECT_EQ(val, 21);
+    } else {
+      EXPECT_EQ(val, 17);
+    }
+  }
+
+  void check5() {
+    if (theContext()->getNode() == 1) {
+      EXPECT_EQ(val, 99);
+    } else {
+      EXPECT_EQ(val, 17);
+    }
+  }
+
+  void cb1(DataMsg* msg) {
+    EXPECT_EQ(msg->a, 8);
+    EXPECT_EQ(msg->b, 9);
+    EXPECT_EQ(msg->c, 10);
+    val = 29;
+  }
+
+  void cb2(DataMsg* msg) {
+    EXPECT_EQ(msg->a, 8);
+    EXPECT_EQ(msg->b, 9);
+    EXPECT_EQ(msg->c, 10);
+    val = 13;
+  }
+
+  void cb3(int a, int b) {
+    EXPECT_EQ(a, 8);
+    EXPECT_EQ(b, 9);
+    val = 15;
+  }
+
+  void cb4(std::string str, int a) {
+    EXPECT_EQ(a, 8);
+    EXPECT_EQ(str, "hello");
+    val = 21;
+  }
+
+public:
+  int32_t val = 17;
+};
+
+static void cb5(TestCol* col, DataMsg* msg) {
+  EXPECT_EQ(msg->a, 8);
+  EXPECT_EQ(msg->b, 9);
+  EXPECT_EQ(msg->c, 10);
+  col->val = 99;
+}
+
+TEST_F(TestCallbackBcastCollective, test_callback_bcast_collective_1) {
+  auto const this_node = theContext()->getNode();
+  auto const range = Index1D(32);
+
+  vt::CollectionProxy<TestCol, vt::Index1D> proxy;
+
+  if (this_node == 0) {
+    proxy = theCollection()->construct<TestCol>(
+      range, "test_callback_bcast_collective_1"
+    );
+  }
+
+  runInEpochCollective([&]{
+    if (this_node == 0) {
+      auto cb = theCB()->makeSendLocalCollectionElement<&TestCol::cb1>(proxy);
+      cb.send(8,9,10);
+    }
+  });
+
+  runInEpochCollective([&]{
+    if (this_node == 0) {
+      proxy.broadcast<&TestCol::check1>();
+    }
+  });
+}
+
+TEST_F(TestCallbackBcastCollective, test_callback_bcast_collective_2) {
+  SET_MIN_NUM_NODES_CONSTRAINT(2);
+
+  auto const this_node = theContext()->getNode();
+  auto const num_nodes = theContext()->getNumNodes();
+
+  auto const range = Index1D(32);
+
+  vt::CollectionProxy<TestCol, vt::Index1D> proxy;
+
+  if (this_node == 0) {
+    proxy = theCollection()->construct<TestCol>(
+      range, "test_callback_bcast_collective_2"
+    );
+  }
+
+  runInEpochCollective([&]{
+    if (this_node == 0) {
+      auto next = this_node + 1 < num_nodes ? this_node + 1 : 0;
+      auto cb = theCB()->makeSendLocalCollectionElement<&TestCol::cb2>(proxy);
+      auto msg = makeMessage<CallbackDataMsg>(cb);
+      theMsg()->sendMsg<testHandler>(next, msg);
+    }
+  });
+
+  runInEpochCollective([&]{
+    if (this_node == 0) {
+      proxy.broadcast<&TestCol::check2>();
+    }
+  });
+}
+
+TEST_F(TestCallbackBcastCollective, test_callback_bcast_collective_param_1) {
+  auto const this_node = theContext()->getNode();
+
+  auto proxy = makeCollection<TestCol>("test_callback_bcast_collective_param_1")
+    .bulkInsert(Index1D(32))
+    .wait();
+
+  runInEpochCollective([&]{
+    if (this_node == 0) {
+      auto cb = theCB()->makeSendLocalCollectionElement<&TestCol::cb3>(proxy);
+      cb.send(8, 9);
+    }
+  });
+
+  runInEpochCollective([&]{
+    proxy.broadcastCollective<&TestCol::check3>();
+  });
+}
+
+TEST_F(TestCallbackBcastCollective, test_callback_bcast_collective_param_2) {
+  auto const this_node = theContext()->getNode();
+
+  auto proxy = makeCollection<TestCol>("test_callback_bcast_collective_param_2")
+    .bulkInsert(Index1D(32))
+    .wait();
+
+  runInEpochCollective([&]{
+    if (this_node == 0) {
+      auto cb = theCB()->makeSendLocalCollectionElement<&TestCol::cb4>(proxy);
+      cb.send("hello", 8);
+    }
+  });
+
+  runInEpochCollective([&]{
+    proxy.broadcastCollective<&TestCol::check4>();
+  });
+}
+
+TEST_F(TestCallbackBcastCollective, test_callback_bcast_collective_3) {
+  SET_MIN_NUM_NODES_CONSTRAINT(2);
+
+  auto const this_node = theContext()->getNode();
+  auto const num_nodes = theContext()->getNumNodes();
+
+  auto const range = Index1D(32);
+
+  vt::CollectionProxy<TestCol, vt::Index1D> proxy;
+
+  if (this_node == 0) {
+    proxy = theCollection()->construct<TestCol>(
+      range, "test_callback_bcast_collection_3"
+    );
+  }
+
+  runInEpochCollective([&]{
+    if (this_node == 0) {
+      auto next = this_node + 1 < num_nodes ? this_node + 1 : 0;
+      auto cb = theCB()->makeSendLocalCollectionElement<cb5>(proxy);
+      auto msg = makeMessage<CallbackDataMsg>(cb);
+      theMsg()->sendMsg<testHandler>(next, msg);
+    }
+  });
+
+  runInEpochCollective([&]{
+    if (this_node == 0) {
+      proxy.broadcast<&TestCol::check5>();
+    }
+  });
+}
+
+}}}} // end namespace vt::tests::unit::pipe