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..8afcb69e3d
--- /dev/null
+++ b/src/vt/collective/reduce/allreduce/data_handler.h
@@ -0,0 +1,126 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                                data_handler.h
+//                       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
+*/
+
+#if !defined INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_DATA_HANDLER_H
+#define INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_DATA_HANDLER_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 size_t size(void) { return 0; }
+};
+
+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 ScalarType fromMemory(const ScalarType* data, size_t) {
+    return *data;
+  }
+
+  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 std::vector<T> fromMemory(const T* data, size_t count) {
+    return std::vector<T>(data, data + count);
+  }
+
+  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) {
+    std::vector<T> vec;
+    vec.resize(data.extent(0));
+    std::memcpy(vec.data(), data.data(), data.extent(0) * sizeof(T));
+    return vec;
+  }
+
+  static ViewType fromMemory(T* data, size_t size) {
+    return ViewType(data, size);
+  }
+
+  static ViewType fromVec(const std::vector<T>& data) {
+    ViewType view("", data.size());
+    Kokkos::parallel_for(
+      "InitView", view.extent(0),
+      KOKKOS_LAMBDA(const int i) { view(i) = static_cast<float>(data[i]); });
+
+    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..1083e32823
--- /dev/null
+++ b/src/vt/collective/reduce/allreduce/helpers.h
@@ -0,0 +1,203 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                                  helpers.h
+//                       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
+*/
+
+#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 <vector>
+#include <type_traits>
+
+namespace vt {
+template <typename T>
+using remove_cvref = std::remove_cv_t<std::remove_reference_t<T>>;
+}
+
+namespace vt::collective::reduce::allreduce {
+
+template <typename Scalar, typename DataT>
+struct DataHelper {
+  using DataType = DataHandler<DataT>;
+
+  template <typename... Args>
+  static void assign(std::vector<Scalar>& dest, Args&&... data) {
+    dest = DataHandler<DataT>::toVec(std::forward<Args>(data)...);
+  }
+
+  static MsgPtr<RabenseifnerMsg<Scalar, DataT>> createMessage(
+    const std::vector<Scalar>& payload, size_t begin, size_t count, size_t id,
+    int32_t step = 0) {
+    return vt::makeMessage<RabenseifnerMsg<Scalar, DataT>>(
+      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 reduce(
+    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]);
+    }
+  }
+
+  static void invoke() { }
+
+  static bool empty(const std::vector<Scalar>& payload) {
+    return payload.empty();
+  }
+};
+
+#if MAGISTRATE_KOKKOS_ENABLED
+
+template <typename Scalar>
+struct DataHelper<Scalar, Kokkos::View<Scalar*, Kokkos::HostSpace>> {
+  using DataT = Kokkos::View<Scalar*, Kokkos::HostSpace>;
+  using DataType = DataHandler<DataT>;
+
+  template <typename... Args>
+  static void assign(DataT& dest, Args&&... data) {
+    dest = {std::forward<Args>(data)...};
+  }
+
+  static MsgPtr<RabenseifnerMsg<Scalar, DataT>> createMessage(
+    const DataT& payload, size_t begin, size_t count, size_t id,
+    int32_t step = 0) {
+    return vt::makeMessage<RabenseifnerMsg<Scalar, DataT>>(
+      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::parallel_for(
+      "Rabenseifner::copy", msg->val_.extent(0),
+      KOKKOS_LAMBDA(const int i) { dest(start_idx + i) = msg->val_(i); }
+    );
+  }
+
+  template <template <typename Arg> class Op>
+  static void reduce(
+    DataT& dest, size_t start_idx, RabenseifnerMsg<Scalar, DataT>* msg) {
+    Kokkos::parallel_for(
+      "Rabenseifner::reduce", msg->val_.extent(0), KOKKOS_LAMBDA(const int i) {
+        Op<Scalar>()(dest(start_idx + i), msg->val_(i));
+      }
+    );
+  }
+
+  static void invoke() { }
+
+  static bool empty(const DataT& payload) {
+    return payload.extent(0) == 0;
+  }
+};
+
+#endif // MAGISTRATE_KOKKOS_ENABLED
+
+struct StateBase {
+  size_t size_ = {};
+
+  bool finished_adjustment_part_ = false;
+
+  int32_t mask_ = 1;
+  int32_t step_ = 0;
+  bool initialized_ = false;
+  bool completed_ = false;
+
+  // 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 Scalar, typename DataT>
+struct State : StateBase {
+  std::vector<Scalar> val_ = {};
+
+  MsgSharedPtr<RabenseifnerMsg<Scalar, DataT>> left_adjust_message_ = nullptr;
+  MsgSharedPtr<RabenseifnerMsg<Scalar, DataT>> right_adjust_message_ = nullptr;
+  std::vector<MsgSharedPtr<RabenseifnerMsg<Scalar, DataT>>> scatter_messages_ = {};
+  std::vector<MsgSharedPtr<RabenseifnerMsg<Scalar, DataT>>> gather_messages_ = {};
+};
+
+#if MAGISTRATE_KOKKOS_ENABLED
+template <typename Scalar>
+struct State<Scalar, Kokkos::View<Scalar*, Kokkos::HostSpace>> : StateBase {
+  using DataT = Kokkos::View<Scalar*, Kokkos::HostSpace>;
+
+  Kokkos::View<Scalar*, Kokkos::HostSpace> val_ = {};
+
+  MsgSharedPtr<RabenseifnerMsg<Scalar, DataT>> left_adjust_message_ = nullptr;
+  MsgSharedPtr<RabenseifnerMsg<Scalar, DataT>> right_adjust_message_ = nullptr;
+  std::vector<MsgSharedPtr<RabenseifnerMsg<Scalar, DataT>>> scatter_messages_ = {};
+  std::vector<MsgSharedPtr<RabenseifnerMsg<Scalar, DataT>>> gather_messages_ = {};
+};
+#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.h b/src/vt/collective/reduce/allreduce/rabenseifner.h
new file mode 100644
index 0000000000..4491170216
--- /dev/null
+++ b/src/vt/collective/reduce/allreduce/rabenseifner.h
@@ -0,0 +1,311 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                                rabenseifner.h
+//                       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
+*/
+
+#if !defined INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_RABENSEIFNER_H
+#define INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_RABENSEIFNER_H
+
+#include "vt/config.h"
+#include "vt/context/context.h"
+#include "vt/messaging/message/message.h"
+#include "vt/objgroup/proxy/proxy_objgroup.h"
+#include "vt/registry/auto/auto_registry.h"
+#include "vt/pipe/pipe_manager.h"
+#include "data_handler.h"
+#include "type.h"
+#include "rabenseifner_msg.h"
+#include "helpers.h"
+
+#include <cstdint>
+
+namespace vt::collective::reduce::allreduce {
+
+// Primary template
+template <typename Scalar, typename DataT>
+struct ShouldUseView {
+  static constexpr bool Value = false;
+};
+
+#if MAGISTRATE_KOKKOS_ENABLED
+// Partial specialization for Kokkos::View
+template <typename Scalar>
+struct ShouldUseView<Scalar, Kokkos::View<Scalar*, Kokkos::HostSpace>> {
+  static constexpr bool Value = true;
+};
+#endif // MAGISTRATE_KOKKOS_ENABLED
+
+// Helper alias for cleaner usage
+template <typename Scalar, typename DataT>
+inline constexpr bool ShouldUseView_v = ShouldUseView<Scalar, DataT>::Value;
+
+/**
+ * \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.
+ *
+ * \tparam DataT Type of the data being reduced.
+ * \tparam Op Reduction operation (e.g., sum, max, min).
+ * \tparam ObjT Object type used for callback invocation.
+ * \tparam finalHandler Callback handler for the final result.
+ */
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT, auto finalHandler
+>
+struct Rabenseifner {
+  using Data = DataT;
+  using DataType = DataHandler<DataT>;
+  using Scalar = typename DataType::Scalar;
+  using ReduceOp = Op<Scalar>;
+  using DataHelperT = DataHelper<Scalar, DataT>;
+  using StateT = State<Scalar, DataT>;
+
+  static constexpr bool KokkosPaylod = ShouldUseView_v<Scalar, DataT>;
+
+  /**
+   * \brief Constructor for Rabenseifner's allreduce algorithm.
+   *
+   * \param parentProxy Proxy to the object group managing the reduction.
+   * \param num_nodes Total number of nodes involved in the allreduce operation.
+   * \param args Additional arguments for initializing the data value.
+   */
+  template <typename ...Args>
+  Rabenseifner(
+    vt::objgroup::proxy::Proxy<ObjT> parentProxy, NodeType num_nodes,
+    Args&&... args);
+
+  /**
+   * \brief Initialize the allreduce algorithm.
+   *
+   * This function sets up the necessary data structures and initial values for the reduction operation.
+   *
+   * \param args Additional arguments for initializing the data value.
+   */
+  template <typename ...Args>
+  void initialize(size_t id, Args&&... args);
+
+  void initializeState(size_t id);
+  size_t generateNewId() { return id_++; }
+
+  /**
+   * \brief Execute the final handler callback with the reduced result.
+   */
+  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.
+   */
+  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.
+   */
+  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.
+   */
+  void adjustForPowerOfTwoRightHalf(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.
+   */
+  void adjustForPowerOfTwoLeftHalf(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.
+   */
+  void adjustForPowerOfTwoFinalPart(RabenseifnerMsg<Scalar, DataT>* msg);
+
+  /**
+   * \brief Check if all scatter messages have been received.
+   *
+   * \return True if all scatter messages have been received, false otherwise.
+   */
+  bool scatterAllMessagesReceived(size_t id);
+
+  /**
+   * \brief Check if the scatter phase is complete.
+   *
+   * \return True if the scatter phase is complete, false otherwise.
+   */
+  bool scatterIsDone(size_t id);
+
+  /**
+   * \brief Check if the scatter phase is ready to proceed.
+   *
+   * \return True if the scatter phase is ready to proceed, false otherwise.
+   */
+  bool scatterIsReady(size_t id);
+
+  /**
+   * \brief Try to reduce the received scatter messages.
+   *
+   * \param step The current step in the scatter phase.
+   */
+  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.
+   */
+  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.
+   */
+  void scatterReduceIterHandler(RabenseifnerMsg<Scalar, DataT>* msg);
+
+  /**
+   * \brief Check if all gather messages have been received.
+   *
+   * \return True if all gather messages have been received, false otherwise.
+   */
+  bool gatherAllMessagesReceived(size_t id);
+
+  /**
+   * \brief Check if the gather phase is complete.
+   *
+   * \return True if the gather phase is complete, false otherwise.
+   */
+  bool gatherIsDone(size_t id);
+
+  /**
+   * \brief Check if the gather phase is ready to proceed.
+   *
+   * \return True if the gather phase is ready to proceed, false otherwise.
+   */
+  bool gatherIsReady(size_t id);
+
+  /**
+   * \brief Try to reduce the received gather messages.
+   *
+   * \param step The current step in the gather phase.
+   */
+  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.
+   */
+  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.
+   */
+  void gatherIterHandler(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.
+   */
+  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.
+   */
+  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.
+   */
+  void sendToExcludedNodesHandler(RabenseifnerMsg<Scalar, DataT>* msg);
+
+  vt::objgroup::proxy::Proxy<Rabenseifner> proxy_ = {};
+  vt::objgroup::proxy::Proxy<ObjT> parent_proxy_ = {};
+
+  size_t id_ = 0;
+  std::unordered_map<size_t, StateT> states_ = {};
+  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 const std::string name_ = "Rabenseifner";
+  static const 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..5e7c42e71c
--- /dev/null
+++ b/src/vt/collective/reduce/allreduce/rabenseifner.impl.h
@@ -0,0 +1,663 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                             rabenseifner.impl.h
+//                       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 "vt/collective/reduce/allreduce/rabenseifner.h"
+#if !defined INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_RABENSEIFNER_IMPL_H
+#define INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_RABENSEIFNER_IMPL_H
+
+#include "vt/collective/reduce/allreduce/data_handler.h"
+#include "vt/config.h"
+
+#include <type_traits>
+
+namespace vt::collective::reduce::allreduce {
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT,
+  auto finalHandler>
+template <typename... Args>
+Rabenseifner<DataT, Op, ObjT, finalHandler>::Rabenseifner(
+  vt::objgroup::proxy::Proxy<ObjT> parentProxy, NodeType num_nodes,
+  Args&&... data)
+  : parent_proxy_(parentProxy),
+    num_nodes_(num_nodes),
+    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_)) {
+  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_;
+  }
+
+  initialize(generateNewId(), std::forward<Args>(data)...);
+}
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT, auto finalHandler
+>void Rabenseifner<DataT, Op, ObjT, finalHandler>::initializeState(size_t id)
+{
+  auto& state = states_[id];
+
+  vt_debug_print(terse, allreduce, "Rabenseifner initializing state for ID = {}\n", id);
+
+  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.finished_adjustment_part_ = not is_part_of_adjustment_group_;
+  state.completed_ = false;
+
+  state.scatter_mask_ = 1;
+  state.scatter_step_ = 0;
+  state.scatter_num_recv_ = 0;
+  state.finished_scatter_part_ = false;
+
+  state.gather_step_ = num_steps_ - 1;
+  state.gather_mask_ = nprocs_pof2_ >> 1;
+  state.gather_num_recv_ = 0;
+
+  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, template <typename Arg> class Op, typename ObjT, auto finalHandler
+>
+template <typename ...Args>
+void Rabenseifner<DataT, Op, ObjT, finalHandler>::initialize(size_t id, Args&&... data) {
+  auto& state = states_[id];
+
+  DataHelper<Scalar, DataT>::assign(state.val_, std::forward<Args>(data)...);
+
+  if(not state.initialized_){
+    initializeState(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++;
+    }
+  }
+
+  vt_debug_print(
+    terse, allreduce,
+    "Rabenseifner initialize: size_ = {} num_steps_ = {} nprocs_pof2_ = {} nprocs_rem_ = "
+    "{} "
+    "is_part_of_adjustment_group_ = {} vrt_node_ = {} ID = {}\n",
+    state.size_, num_steps_, nprocs_pof2_, nprocs_rem_, is_part_of_adjustment_group_,
+    vrt_node_, id
+  );
+}
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT, auto finalHandler
+>
+void Rabenseifner<DataT, Op, ObjT, finalHandler>::executeFinalHan(size_t id) {
+  auto& state = states_.at(id);
+  vt_debug_print(terse, allreduce, "Rabenseifner executing final handler ID = {}\n", id);
+
+  // TODO convert
+  parent_proxy_[this_node_].template invoke<finalHandler>(state.val_);
+  state.completed_ = true;
+}
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT,
+  auto finalHandler>
+void Rabenseifner<DataT, Op, ObjT, finalHandler>::allreduce(size_t id) {
+  if (is_part_of_adjustment_group_) {
+    adjustForPowerOfTwo(id);
+  } else {
+    scatterReduceIter(id);
+  }
+}
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT, auto finalHandler
+>
+void Rabenseifner<DataT, Op, ObjT, finalHandler>::adjustForPowerOfTwo(size_t id) {
+  if (is_part_of_adjustment_group_) {
+    auto& state = states_.at(id);
+    auto const partner = is_even_ ? this_node_ + 1 : this_node_ - 1;
+
+    vt_debug_print(
+      terse, allreduce, "Rabenseifner AdjustInitial (To {}): ID = {}\n", partner, id
+    );
+
+    if (is_even_) {
+      proxy_[partner]
+        .template sendMsg<&Rabenseifner::adjustForPowerOfTwoRightHalf>(
+          DataHelperT::createMessage(
+            state.val_, state.size_ / 2, state.size_ - (state.size_ / 2), id
+          )
+        );
+
+      if(state.left_adjust_message_ != nullptr){
+        adjustForPowerOfTwoLeftHalf(state.left_adjust_message_.get());
+      }
+    } else {
+      proxy_[partner]
+        .template sendMsg<&Rabenseifner::adjustForPowerOfTwoLeftHalf>(
+          DataHelperT::createMessage(state.val_, 0, state.size_ / 2, id)
+        );
+
+      if(state.right_adjust_message_ != nullptr){
+        adjustForPowerOfTwoRightHalf(state.right_adjust_message_.get());
+      }
+    }
+  }
+}
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT, auto finalHandler
+>
+void Rabenseifner<DataT, Op, ObjT, finalHandler>::adjustForPowerOfTwoRightHalf(
+  RabenseifnerMsg<Scalar, DataT>* msg) {
+
+  auto& state = states_[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(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 reduce<Op>(state.val_, state.size_ / 2, msg);
+
+  // Send to left node
+  proxy_[theContext()->getNode() - 1]
+    .template sendMsg<&Rabenseifner::adjustForPowerOfTwoFinalPart>(
+      DataHelperT::createMessage(state.val_, state.size_ / 2, state.size_ - (state.size_ / 2), msg->id_)
+    );
+}
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT, auto finalHandler
+>
+void Rabenseifner<DataT, Op, ObjT, finalHandler>::adjustForPowerOfTwoLeftHalf(
+  RabenseifnerMsg<Scalar, DataT>* msg) {
+
+  auto& state = states_[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(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 reduce<Op>(state.val_, 0, msg);
+}
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT, auto finalHandler
+>
+void Rabenseifner<DataT, Op, ObjT, finalHandler>::adjustForPowerOfTwoFinalPart(
+  RabenseifnerMsg<Scalar, DataT>* msg) {
+
+  vt_debug_print(
+    terse, allreduce, "Rabenseifner AdjustFinal (From {}): ID = {}\n",
+    theContext()->getFromNodeCurrentTask(), msg->id_
+  );
+
+  auto& state = states_[msg->id_];
+
+  DataHelperT::copy(state.val_, state.size_ / 2, msg);
+
+  state.finished_adjustment_part_ = true;
+
+  scatterReduceIter(msg->id_);
+}
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT, auto finalHandler
+>
+bool Rabenseifner<DataT, Op, ObjT, finalHandler>::scatterAllMessagesReceived(size_t id) {
+  auto const& state = states_.at(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, template <typename Arg> class Op, typename ObjT, auto finalHandler
+>
+bool Rabenseifner<DataT, Op, ObjT, finalHandler>::scatterIsDone(size_t id) {
+  auto const& state = states_.at(id);
+  return (state.scatter_step_ == num_steps_) and (state.scatter_num_recv_ == num_steps_);
+}
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT, auto finalHandler
+>
+bool Rabenseifner<DataT, Op, ObjT, finalHandler>::scatterIsReady(size_t id) {
+  auto const& state = states_.at(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(id));
+}
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT, auto finalHandler
+>
+void Rabenseifner<DataT, Op, ObjT, finalHandler>::scatterTryReduce(
+  size_t id, int32_t step) {
+  auto& state = states_.at(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 reduce<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, typename ObjT, auto finalHandler
+>
+void Rabenseifner<DataT, Op, ObjT, finalHandler>::scatterReduceIter(size_t id) {
+  if (not scatterIsReady(id)) {
+    return;
+  }
+
+  auto& state = states_.at(id);
+  auto vdest = vrt_node_ ^ state.scatter_mask_;
+  auto dest = (vdest < nprocs_rem_) ? vdest * 2 : vdest + nprocs_rem_;
+
+  vt_debug_print(
+    terse, allreduce,
+    "Rabenseifner Scatter (Send step {} to {}): Starting with idx = {} and "
+    "count "
+    "{} ID = {}\n",
+    state.scatter_step_, dest, state.s_index_[state.scatter_step_],
+    state.s_count_[state.scatter_step_], id
+  );
+
+  proxy_[dest].template sendMsg<&Rabenseifner::scatterReduceIterHandler>(
+    DataHelperT::createMessage(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(id, state.scatter_step_ - 1);
+
+  if (scatterIsDone(id)) {
+    state.finished_scatter_part_ = true;
+    gatherIter(id);
+  } else {
+    scatterReduceIter(id);
+  }
+}
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT, auto finalHandler
+>
+void Rabenseifner<DataT, Op, ObjT, finalHandler>::scatterReduceIterHandler(
+  RabenseifnerMsg<Scalar, DataT>* msg) {
+  auto& state = states_[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(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(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(msg->id_, msg->step_);
+
+  if ((state.scatter_mask_ < nprocs_pof2_) and scatterAllMessagesReceived(msg->id_)) {
+    scatterReduceIter(msg->id_);
+  } else if (scatterIsDone(msg->id_)) {
+    state.finished_scatter_part_ = true;
+    gatherIter(msg->id_);
+  }
+}
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT, auto finalHandler
+>
+bool Rabenseifner<DataT, Op, ObjT, finalHandler>::gatherAllMessagesReceived(size_t id) {
+  auto& state = states_.at(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, template <typename Arg> class Op, typename ObjT, auto finalHandler
+>
+bool Rabenseifner<DataT, Op, ObjT, finalHandler>::gatherIsDone(size_t id) {
+  auto& state = states_.at(id);
+  return (state.gather_step_ < 0) and (state.gather_num_recv_ == num_steps_);
+}
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT, auto finalHandler
+>
+bool Rabenseifner<DataT, Op, ObjT, finalHandler>::gatherIsReady(size_t id) {
+  auto& state = states_.at(id);
+  return (state.gather_step_ == num_steps_ - 1) or gatherAllMessagesReceived(id);
+}
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT, auto finalHandler
+>
+void Rabenseifner<DataT, Op, ObjT, finalHandler>::gatherTryReduce(
+  size_t id, int32_t step) {
+  auto& state = states_.at(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, template <typename Arg> class Op, typename ObjT, auto finalHandler
+>
+void Rabenseifner<DataT, Op, ObjT, finalHandler>::gatherIter(size_t id) {
+  if (not gatherIsReady(id)) {
+    return;
+  }
+
+  auto& state = states_.at(id);
+  auto vdest = vrt_node_ ^ state.gather_mask_;
+  auto dest = (vdest < nprocs_rem_) ? vdest * 2 : vdest + nprocs_rem_;
+
+  vt_debug_print(
+    terse, allreduce,
+    "Rabenseifner Gather (step {}): Sending to Node {} starting with idx = {} and "
+    "count "
+    "{} ID = {}\n",
+    state.gather_step_, dest, state.r_index_[state.gather_step_],
+    state.r_count_[state.gather_step_], id
+  );
+
+  proxy_[dest].template sendMsg<&Rabenseifner::gatherIterHandler>(
+    DataHelperT::createMessage(
+      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(id, state.gather_step_ + 1);
+
+  if (gatherIsDone(id)) {
+    finalPart(id);
+  } else if (gatherIsReady(id)) {
+    gatherIter(id);
+  }
+}
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT, auto finalHandler
+>
+void Rabenseifner<DataT, Op, ObjT, finalHandler>::gatherIterHandler(
+  RabenseifnerMsg<Scalar, DataT>* msg) {
+  auto& state = states_.at(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(msg->id_, msg->step_);
+
+  if (state.gather_mask_ > 0 and gatherIsReady(msg->id_)) {
+    gatherIter(msg->id_);
+  } else if (gatherIsDone(msg->id_)) {
+    finalPart(msg->id_);
+  }
+}
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT, auto finalHandler
+>
+void Rabenseifner<DataT, Op, ObjT, finalHandler>::finalPart(size_t id) {
+  auto& state = states_.at(id);
+  if (state.completed_) {
+    return;
+  }
+
+  if (nprocs_rem_) {
+    sendToExcludedNodes(id);
+  }
+
+  vt_debug_print(
+    terse, allreduce,
+    "Rabenseifner::finalPart(): Executing final handler with size {} ID = {}\n",
+    state.val_.size(), id
+  );
+
+  if constexpr (ShouldUseView_v<Scalar, DataT>) {
+    parent_proxy_[this_node_].template invoke<finalHandler>(state.val_);
+  } else {
+    parent_proxy_[this_node_].template invoke<finalHandler>(
+      DataType::fromVec(state.val_)
+    );
+  }
+
+  state.completed_ = true;
+
+  std::fill(state.scatter_messages_.begin(), state.scatter_messages_.end(), nullptr);
+  std::fill(state.gather_messages_.begin(), state.gather_messages_.end(), nullptr);
+
+  state.scatter_steps_recv_.assign(num_steps_, false);
+  state.gather_steps_recv_.assign(num_steps_, false);
+
+  state.scatter_steps_reduced_.assign(num_steps_, false);
+  state.gather_steps_reduced_.assign(num_steps_, false);
+
+  state.r_index_.assign(num_steps_, 0);
+  state.r_count_.assign(num_steps_, 0);
+  state.s_index_.assign(num_steps_, 0);
+  state.s_count_.assign(num_steps_, 0);
+}
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT, auto finalHandler
+>
+void Rabenseifner<DataT, Op, ObjT, finalHandler>::sendToExcludedNodes(size_t id) {
+  auto& state = states_.at(id);
+  if (is_part_of_adjustment_group_ and is_even_) {
+    vt_debug_print(
+      terse, allreduce, "Rabenseifner::sendToExcludedNodes(): Sending to Node {} ID = {}\n",
+      this_node_ + 1, id
+    );
+
+    proxy_[this_node_ + 1]
+      .template sendMsg<&Rabenseifner::sendToExcludedNodesHandler>(
+        DataHelperT::createMessage(state.val_, 0, state.size_, id)
+      );
+  }
+}
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT, auto finalHandler
+>
+void Rabenseifner<DataT, Op, ObjT, finalHandler>::sendToExcludedNodesHandler(
+  RabenseifnerMsg<Scalar, DataT>* msg) {
+  auto& state = states_.at(msg->id_);
+  vt_debug_print(
+    terse, allreduce,
+    "Rabenseifner::sendToExcludedNodesHandler(): Received allreduce result "
+    "with ID = {}\n",
+    msg->id_
+  );
+
+  if constexpr (ShouldUseView_v<Scalar, DataT>) {
+    parent_proxy_[this_node_].template invoke<finalHandler>(msg->val_);
+  } else {
+    parent_proxy_[this_node_].template invoke<finalHandler>(
+      DataType::fromMemory(msg->val_, msg->size_));
+  }
+
+  state.completed_ = true;
+}
+
+} // 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..9bf2653d7b
--- /dev/null
+++ b/src/vt/collective/reduce/allreduce/rabenseifner_msg.h
@@ -0,0 +1,129 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                              rabenseifner_msg.h
+//                       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
+*/
+
+#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/messaging/active.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(const Scalar* in_val, size_t size, size_t id, int step = 0)
+    : MessageParentType(),
+      val_(in_val),
+      size_(size),
+      id_(id),
+      step_(step) { }
+
+  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_;
+  }
+
+  const Scalar* val_ = {};
+  size_t size_ = {};
+  size_t id_ = {};
+  int32_t step_ = {};
+  bool owning_ = false;
+};
+
+#if MAGISTRATE_KOKKOS_ENABLED
+template <typename Scalar>
+struct RabenseifnerMsg<Scalar, Kokkos::View<Scalar*, Kokkos::HostSpace>> : Message {
+  using ViewT = Kokkos::View<Scalar*, Kokkos::HostSpace>;
+  using MessageParentType = vt::Message;
+  vt_msg_serialize_required();
+
+  RabenseifnerMsg() = default;
+  RabenseifnerMsg(RabenseifnerMsg const&) = default;
+  RabenseifnerMsg(RabenseifnerMsg&&) = default;
+
+  RabenseifnerMsg(const ViewT& in_val, size_t id, int step = 0)
+    : MessageParentType(),
+      val_(in_val),
+      id_(id),
+      step_(step) { }
+
+  template <typename SerializeT>
+  void serialize(SerializeT& s) {
+    MessageParentType::serialize(s);
+
+    s | val_;
+    s | id_;
+    s | step_;
+  }
+
+  ViewT val_ = {};
+  size_t id_ = {};
+  int32_t step_ = {};
+};
+#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.h b/src/vt/collective/reduce/allreduce/recursive_doubling.h
new file mode 100644
index 0000000000..bbda3dec06
--- /dev/null
+++ b/src/vt/collective/reduce/allreduce/recursive_doubling.h
@@ -0,0 +1,267 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                             recursive_doubling.h
+//                       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
+*/
+
+#if !defined INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_RECURSIVE_DOUBLING_H
+#define INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_RECURSIVE_DOUBLING_H
+
+#include "vt/config.h"
+#include "vt/context/context.h"
+#include "vt/messaging/message/message.h"
+#include "vt/objgroup/proxy/proxy_objgroup.h"
+#include "vt/configs/error/config_assert.h"
+#include "vt/messaging/message/smart_ptr.h"
+#include "data_handler.h"
+#include "type.h"
+
+#include <tuple>
+#include <cstdint>
+
+namespace vt::collective::reduce::allreduce {
+
+template <typename DataT>
+struct AllreduceDblRawMsg
+  : Message {
+    using MessageParentType = vt::Message;
+    vt_msg_serialize_required();
+
+
+  AllreduceDblRawMsg() = default;
+  AllreduceDblRawMsg(AllreduceDblRawMsg const&) = default;
+  AllreduceDblRawMsg(AllreduceDblRawMsg&&) = default;
+  ~AllreduceDblRawMsg() {
+    if (owning_) {
+      delete val_;
+    }
+  }
+
+  AllreduceDblRawMsg(DataT const& in_val, size_t id, int step = 0)
+    : MessageParentType(),
+      val_(&in_val),
+      id_(id),
+      step_(step) { }
+
+  template <typename SerializeT>
+  void serialize(SerializeT& s) {
+      MessageParentType::serialize(s);
+
+      if (s.isUnpacking()) {
+        owning_ = true;
+        val_ = new DataT();
+      }
+
+      s | *val_;
+      s | id_;
+      s | step_;
+  }
+
+  const DataT* val_ = {};
+  size_t id_ = {};
+  int32_t step_ = {};
+  bool owning_ = false;
+};
+
+/**
+ * \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.
+ *
+ * \tparam DataT The data type to be reduced.
+ * \tparam Op The reduction operation type.
+ * \tparam ObjT The object type.
+ * \tparam finalHandler The final handler.
+ */
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT,
+  auto finalHandler>
+struct RecursiveDoubling {
+  using Data = DataT;
+  using DataType = DataHandler<DataT>;
+  using Scalar = typename DataHandler<DataT>::Scalar;
+  using ReduceOp = Op<Scalar>;
+  /**
+   * \brief Constructor for RecursiveDoubling class.
+   *
+   * Initializes the RecursiveDoubling object with the provided parameters.
+   *
+   * \param parentProxy The parent proxy.
+   * \param num_nodes The number of nodes.
+   * \param args Additional arguments for data initialization.
+   */
+  template <typename... Args>
+  RecursiveDoubling(
+    vt::objgroup::proxy::Proxy<ObjT> parentProxy, NodeType num_nodes,
+    Args&&... data);
+
+  /**
+   * \brief Start the allreduce operation.
+   */
+  void allreduce(size_t id);
+
+  /**
+   * \brief Initialize the RecursiveDoubling object.
+   *
+   * \param args Additional arguments for data initialization.
+   */
+  template <typename... Args>
+  void initialize(size_t id, Args&&... data);
+  void initializeState(size_t id);
+
+  size_t generateNewId() { return id_++; }
+
+  /**
+   * \brief Adjust for power of two nodes.
+   */
+  void adjustForPowerOfTwo(size_t id);
+
+  /**
+   * \brief Handler for adjusting for power of two nodes.
+   *
+   * \param msg Pointer to the message.
+   */
+  void adjustForPowerOfTwoHandler(AllreduceDblRawMsg<DataT>* msg);
+
+  /**
+   * \brief Check if the allreduce operation is done.
+   *
+   * \return True if the operation is done, otherwise false.
+   */
+  bool isDone(size_t id);
+
+  /**
+   * \brief Check if the current state is valid for allreduce.
+   *
+   * \return True if the state is valid, otherwise false.
+   */
+  bool isValid(size_t id);
+
+  /**
+   * \brief Check if all messages are received for the current step.
+   *
+   * \return True if all messages are received, otherwise false.
+   */
+  bool allMessagesReceived(size_t id);
+
+  /**
+   * \brief Check if the object is ready for the next step of allreduce.
+   *
+   * \return True if ready, otherwise false.
+   */
+  bool isReady(size_t id);
+
+  /**
+   * \brief Perform the next step of the allreduce operation.
+   */
+  void reduceIter(size_t id);
+
+  /**
+   * \brief Try to reduce the message at the specified step.
+   *
+   * \param step The step at which to try reduction.
+   */
+  void tryReduce(size_t id, int32_t step);
+
+  /**
+   * \brief Handler for the reduce iteration.
+   *
+   * \param msg Pointer to the message.
+   */
+  void reduceIterHandler(AllreduceDblRawMsg<DataT>* msg);
+
+  /**
+   * \brief Send data to excluded nodes for finalization.
+   */
+  void sendToExcludedNodes(size_t id);
+
+  /**
+   * \brief Handler for sending data to excluded nodes.
+   *
+   * \param msg Pointer to the message.
+   */
+  void sendToExcludedNodesHandler(AllreduceDblRawMsg<DataT>* msg);
+
+  /**
+   * \brief Perform the final part of the allreduce operation.
+   */
+  void finalPart(size_t id);
+
+  vt::objgroup::proxy::Proxy<RecursiveDoubling> proxy_ = {};
+  vt::objgroup::proxy::Proxy<ObjT> parent_proxy_ = {};
+
+  struct State{
+    DataT val_ = {};
+    bool finished_adjustment_part_ = false;
+    MsgSharedPtr<AllreduceDblRawMsg<DataT>> adjust_message_ = nullptr;
+
+    int32_t mask_ = 1;
+    int32_t step_ = 0;
+    bool initialized_ = false;
+    bool completed_ = false;
+
+    std::vector<bool> steps_recv_ = {};
+    std::vector<bool> steps_reduced_ = {};
+    std::vector<MsgSharedPtr<AllreduceDblRawMsg<DataT>>> messages_ = {};
+  };
+
+  size_t id_ = 0;
+  std::unordered_map<size_t, State> states_ = {};
+
+  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::RedursiveDoubling;
+};
+
+} // 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..a744bda957
--- /dev/null
+++ b/src/vt/collective/reduce/allreduce/recursive_doubling.impl.h
@@ -0,0 +1,361 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                          recursive_doubling.impl.h
+//                       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
+*/
+
+#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"
+
+namespace vt::collective::reduce::allreduce {
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT,
+  auto finalHandler>
+template <typename... Args>
+RecursiveDoubling<DataT, Op, ObjT, finalHandler>::RecursiveDoubling(
+  vt::objgroup::proxy::Proxy<ObjT> parentProxy, NodeType num_nodes,
+  Args&&... data)
+  : parent_proxy_(parentProxy),
+    num_nodes_(num_nodes),
+    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_)){
+  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_;
+  }
+
+  initialize(generateNewId(), std::forward<Args>(data)...);
+}
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT,
+  auto finalHandler>
+template <typename ...Args>
+void RecursiveDoubling<DataT, Op, ObjT, finalHandler>::initialize(
+  size_t id, Args&&... data) {
+  auto& state = states_[id];
+
+  if(not state.initialized_){
+    initializeState(id);
+  }
+
+  state.val_ = DataT{std::forward<Args>(data)...};
+
+  vt_debug_print(
+    terse, allreduce, "RecursiveDoubling Initialize: size {} ID {}\n",
+    DataType::size(state.val_), id
+  );
+}
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT,
+  auto finalHandler>
+void RecursiveDoubling<DataT, Op, ObjT, finalHandler>::initializeState(size_t id){
+  auto& state = states_[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, typename ObjT,
+  auto finalHandler>
+void RecursiveDoubling<DataT, Op, ObjT, finalHandler>::allreduce(size_t id) {
+  if (is_part_of_adjustment_group_) {
+    adjustForPowerOfTwo(id);
+  } else {
+    reduceIter(id);
+  }
+}
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT,
+  auto finalHandler>
+void RecursiveDoubling<DataT, Op, ObjT, finalHandler>::adjustForPowerOfTwo(size_t id) {
+  auto& state = states_.at(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
+    );
+
+    proxy_[this_node_ - 1]
+      .template send<&RecursiveDoubling::adjustForPowerOfTwoHandler>(state.val_, id);
+  }else if(state.adjust_message_ != nullptr){
+    // We have pending reduce message
+    adjustForPowerOfTwoHandler(state.adjust_message_.get());
+  }
+}
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT,
+  auto finalHandler>
+void RecursiveDoubling<DataT, Op, ObjT, finalHandler>::
+  adjustForPowerOfTwoHandler(AllreduceDblRawMsg<DataT>* msg) {
+
+  auto& state = states_[msg->id_];
+  if (DataType::size(state.val_) == 0) {
+    if (not state.initialized_) {
+      initializeState(msg->id_);
+    }
+    state.adjust_message_ = promoteMsg(msg);
+
+    return;
+  }
+
+  Op<DataT>()(state.val_, *(msg->val_));
+
+  state.finished_adjustment_part_ = true;
+
+  reduceIter(msg->id_);
+}
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT,
+  auto finalHandler>
+bool RecursiveDoubling<DataT, Op, ObjT, finalHandler>::isDone(size_t id) {
+  auto& state = states_.at(id);
+  return (state.step_ == num_steps_) and allMessagesReceived(id);
+}
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT,
+  auto finalHandler>
+bool RecursiveDoubling<DataT, Op, ObjT, finalHandler>::isValid(size_t id) {
+  auto& state = states_.at(id);
+  return (vrt_node_ != -1) and (state.step_ < num_steps_);
+}
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT,
+  auto finalHandler>
+bool RecursiveDoubling<DataT, Op, ObjT, finalHandler>::allMessagesReceived(size_t id) {
+  auto& state = states_.at(id);
+  return std::all_of(
+    state.steps_recv_.cbegin(), state.steps_recv_.cbegin() + state.step_,
+    [](const auto val) { return val; });
+}
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT,
+  auto finalHandler>
+bool RecursiveDoubling<DataT, Op, ObjT, finalHandler>::isReady(size_t id) {
+  auto& state = states_.at(id);
+  return ((is_part_of_adjustment_group_ and state.finished_adjustment_part_) and
+          state.step_ == 0) or
+    allMessagesReceived(id);
+}
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT,
+  auto finalHandler>
+void RecursiveDoubling<DataT, Op, ObjT, finalHandler>::reduceIter(size_t id) {
+  // Ensure we have received all necessary messages
+  if (not isReady(id)) {
+    return;
+  }
+
+  auto& state = states_.at(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
+  );
+
+  proxy_[dest].template send<&RecursiveDoubling::reduceIterHandler>(state.val_, id, state.step_);
+
+  state.mask_ <<= 1;
+  state.step_++;
+
+  tryReduce(id, state.step_ - 1);
+
+  if (isDone(id)) {
+    finalPart(id);
+  } else if (isReady(id)) {
+    reduceIter(id);
+  }
+}
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT,
+  auto finalHandler>
+void RecursiveDoubling<DataT, Op, ObjT, finalHandler>::tryReduce(size_t id, int32_t step) {
+  auto& state = states_.at(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, typename ObjT,
+  auto finalHandler>
+void RecursiveDoubling<DataT, Op, ObjT, finalHandler>::reduceIterHandler(
+  AllreduceDblRawMsg<DataT>* msg) {
+  auto& state = states_[msg->id_];
+
+  if (DataType::size(state.val_) == 0) {
+    if (not state.initialized_) {
+      initializeState(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(msg->id_, msg->step_);
+
+  if ((state.mask_ < nprocs_pof2_) and isReady(msg->id_)) {
+    reduceIter(msg->id_);
+
+  } else if (isDone(msg->id_)) {
+    finalPart(msg->id_);
+  }
+}
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT,
+  auto finalHandler>
+void RecursiveDoubling<DataT, Op, ObjT, finalHandler>::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 = states_.at(id);
+    proxy_[this_node_ + 1]
+      .template send<&RecursiveDoubling::sendToExcludedNodesHandler>(state.val_, id);
+  }
+}
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT,
+  auto finalHandler>
+void RecursiveDoubling<DataT, Op, ObjT, finalHandler>::
+  sendToExcludedNodesHandler(AllreduceDblRawMsg<DataT>* msg) {
+
+  parent_proxy_[this_node_].template invoke<finalHandler>(*(msg->val_));
+
+  states_.at(msg->id_).completed_ = true;
+}
+
+template <
+  typename DataT, template <typename Arg> class Op, typename ObjT,
+  auto finalHandler>
+void RecursiveDoubling<DataT, Op, ObjT, finalHandler>::finalPart(size_t id) {
+  auto& state = states_.at(id);
+  if (state.completed_) {
+    return;
+  }
+
+  vt_debug_print(
+    terse, allreduce,
+    "RecursiveDoubling Part4: Executing final handler ID = {}\n", id
+  );
+
+  if (nprocs_rem_) {
+    sendToExcludedNodes(id);
+  }
+
+  parent_proxy_[this_node_].template invoke<finalHandler>(state.val_);
+
+  state.completed_ = true;
+}
+
+} // namespace vt::collective::reduce::allreduce
+
+#endif /*INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_RECURSIVE_DOUBLING_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..7b854823c2
--- /dev/null
+++ b/src/vt/collective/reduce/allreduce/type.h
@@ -0,0 +1,63 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                                    type.h
+//                       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
+*/
+
+#if !defined INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_TYPE_H
+#define INCLUDED_VT_COLLECTIVE_REDUCE_ALLREDUCE_TYPE_H
+
+#include <string>
+
+namespace vt::collective::reduce::allreduce {
+
+enum class ReducerType { Rabenseifner, RedursiveDoubling };
+
+inline std::string TypeToString(ReducerType t) {
+  if (t == ReducerType::Rabenseifner) {
+    return "Rabenseifner";
+  } else {
+    return "RedursiveDoubling";
+  }
+}
+
+} // 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 72f2d68f4d..37994c8714 100644
--- a/src/vt/collective/reduce/operators/functors/plus_op.h
+++ b/src/vt/collective/reduce/operators/functors/plus_op.h
@@ -65,6 +65,19 @@ struct PlusOp<std::tuple<Params...>> {
   }
 };
 
+#if MAGISTRATE_KOKKOS_ENABLED
+template <typename T>
+struct PlusOp<Kokkos::View<T*, Kokkos::HostSpace>> {
+  void operator()(
+    Kokkos::View<T*, Kokkos::HostSpace>& v1,
+    Kokkos::View<T*, Kokkos::HostSpace> const& v2) {
+    Kokkos::parallel_for(
+      "Initialize", v1.extent(0),
+      KOKKOS_LAMBDA(const int i) { v1(i) += v2(i); });
+  }
+};
+#endif // MAGISTRATE_KOKKOS_ENABLED
+
 template <typename T>
 struct PlusOp< std::vector<T> > {
   void operator()(std::vector<T>& v1, std::vector<T> const& v2) {
diff --git a/src/vt/configs/arguments/app_config.h b/src/vt/configs/arguments/app_config.h
index aa83d05588..47040d825b 100644
--- a/src/vt/configs/arguments/app_config.h
+++ b/src/vt/configs/arguments/app_config.h
@@ -228,6 +228,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;
 
@@ -390,6 +391,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 ee3e6f8c25..4a50b99a69 100644
--- a/src/vt/configs/arguments/args.cc
+++ b/src/vt/configs/arguments/args.cc
@@ -807,6 +807,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);
 
@@ -844,6 +845,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);
@@ -881,6 +883,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 bde85b0620..7e7c64e123 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/objgroup/manager.h b/src/vt/objgroup/manager.h
index 8d144dc14c..3f2d948e2f 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,12 @@ struct ObjGroupManager : runtime::component::Component<ObjGroupManager> {
     ProxyType<ObjT> proxy, std::string const& name, std::string const& parent = ""
   );
 
+template <typename Reducer, typename ObjT, typename... Args>
+ObjGroupManager::PendingSendType allreduce(ProxyType<ObjT> proxy, Args&&... data);
+
+template <auto f, typename ObjT, template <typename Arg> class Op, typename DataT, typename... Args>
+ObjGroupManager::PendingSendType allreduce(ProxyType<ObjT> proxy, Args&&... data);
+
   /**
    * \brief Perform a reduction over an objgroup
    *
@@ -501,6 +514,10 @@ struct ObjGroupManager : runtime::component::Component<ObjGroupManager> {
   std::unordered_map<ObjGroupProxyType, std::vector<ActionType>> pending_;
   /// Map of object groups' labels
   std::unordered_map<ObjGroupProxyType, std::string> labels_;
+  /// Recursive Doubling reducers
+  ReducerMapType reducers_recursive_doubling_;
+  /// Rabenseifner reducers
+  ReducerMapType reducers_rabenseifner_;
 };
 
 }} /* end namespace vt::objgroup */
diff --git a/src/vt/objgroup/manager.impl.h b/src/vt/objgroup/manager.impl.h
index ff24ee549c..eb63b5f031 100644
--- a/src/vt/objgroup/manager.impl.h
+++ b/src/vt/objgroup/manager.impl.h
@@ -57,6 +57,13 @@
 #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 <utility>
+#include <array>
 
 #include <memory>
 
@@ -262,6 +269,85 @@ ObjGroupManager::PendingSendType ObjGroupManager::broadcast(MsgSharedPtr<MsgT> m
   return objgroup::broadcast(msg,han);
 }
 
+template <typename Reducer, typename ObjT, typename... Args>
+ObjGroupManager::PendingSendType ObjGroupManager::allreduce(
+  ProxyType<ObjT> proxy, Args&&... data) {
+  using namespace vt::collective::reduce::allreduce;
+
+  auto const this_node = vt::theContext()->getNode();
+  auto const num_nodes = theContext()->getNumNodes();
+  size_t id = 0;
+
+  proxy::Proxy<Reducer> grp_proxy = {};
+
+  auto& reducers = Reducer::type_ == ReducerType::Rabenseifner ?
+    reducers_rabenseifner_ :
+    reducers_recursive_doubling_;
+  auto const key = std::make_tuple(
+    proxy.getProxy(), std::type_index(typeid(typename Reducer::Data)),
+    std::type_index(typeid(typename Reducer::ReduceOp))
+  );
+  if (reducers.find(key) != reducers.end()) {
+    vt_debug_print(
+      verbose, allreduce, "Found reducer (type: {}) for proxy {:x}",
+      TypeToString(Reducer::type_), proxy.getProxy()
+    );
+
+    auto* obj =
+      reinterpret_cast<Reducer*>(objs_.at(reducers.at(key))->getPtr());
+    id = obj->generateNewId();
+    obj->initialize(id, std::forward<Args>(data)...);
+    grp_proxy = obj->proxy_;
+  } else {
+    vt_debug_print(
+      verbose, allreduce, "Creating reducer (type: {}) for proxy {:x}",
+      TypeToString(Reducer::type_), proxy.getProxy()
+    );
+
+    grp_proxy = vt::theObjGroup()->makeCollective<Reducer>(
+      TypeToString(Reducer::type_), proxy, num_nodes,
+      std::forward<Args>(data)...
+    );
+    grp_proxy[this_node].get()->proxy_ = grp_proxy;
+    reducers[key] = grp_proxy.getProxy();
+    id = grp_proxy[this_node].get()->id_ - 1;
+  }
+
+  return PendingSendType{
+    theTerm()->getEpoch(),
+    [=] { grp_proxy[this_node].template invoke<&Reducer::allreduce>(id); }
+  };
+}
+
+template <auto f, typename ObjT, template <typename Arg> class Op, typename DataT, typename... Args>
+ObjGroupManager::PendingSendType
+ObjGroupManager::allreduce(ProxyType<ObjT> proxy, Args&&... data) {
+  if (theContext()->getNumNodes() < 2) {
+    return PendingSendType{theTerm()->getEpoch(), [&] {
+      auto const this_node = vt::theContext()->getNode();
+      proxy[this_node].template invoke<f>(std::forward<Args>(data)...);
+    }};
+  }
+
+  auto const payload_size =
+    collective::reduce::allreduce::DataHandler<remove_cvref<DataT>>::size(
+      std::forward<Args>(data)...
+    );
+
+  if (payload_size < 2048) {
+    using Reducer =
+      vt::collective::reduce::allreduce::RecursiveDoubling<DataT, Op, ObjT, f>;
+    return allreduce<Reducer>(proxy, std::forward<Args>(data)...);
+  } else {
+    using Reducer =
+      vt::collective::reduce::allreduce::Rabenseifner<DataT, Op, ObjT, f>;
+    return allreduce<Reducer>(proxy, std::forward<Args>(data)...);
+  }
+
+  // Silence nvcc warning
+  return PendingSendType{nullptr};
+}
+
 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 a38cb984f2..1854888009 100644
--- a/src/vt/objgroup/proxy/proxy_objgroup.h
+++ b/src/vt/objgroup/proxy/proxy_objgroup.h
@@ -198,6 +198,15 @@ struct Proxy {
     Args&&... args
   ) const;
 
+  template <
+    auto f,
+    template <typename Arg> class Op = collective::NoneOp,
+    typename... Args
+  >
+  PendingSendType allreduce_h(
+    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 f546b65719..2252856822 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,22 @@ Proxy<ObjT>::allreduce(
   >(proxy, msg.get(), stamp);
 }
 
+template <typename ObjT>
+template <
+  auto f,
+  template <typename Arg> class Op,
+  typename... Args
+>
+typename Proxy<ObjT>::PendingSendType
+Proxy<ObjT>::allreduce_h(
+  Args&&... args
+) const {
+  auto proxy = Proxy<ObjT>(*this);
+
+  return theObjGroup()->allreduce<f, ObjT, Op, remove_cvref<Args>...>(
+    proxy, std::forward<Args>(args)...);
+}
+
 template <typename ObjT>
 template <
   auto f,
diff --git a/src/vt/utils/hash/hash_tuple.h b/src/vt/utils/hash/hash_tuple.h
index 9e1c0095d2..ba1ffc5381 100644
--- a/src/vt/utils/hash/hash_tuple.h
+++ b/src/vt/utils/hash/hash_tuple.h
@@ -47,16 +47,44 @@
 #include <tuple>
 
 namespace std {
+namespace {
 
-template <typename A, typename B>
-struct hash<std::tuple<A, B>> {
-  size_t operator()(std::tuple<A, B> const& in) const {
-    auto const& v1 = std::hash<A>()(std::get<0>(in));
-    auto const& v2 = std::hash<B>()(std::get<1>(in));
-    return v1 ^ v2;
+// Code from boost
+// Reciprocal of the golden ratio helps spread entropy
+//     and handles duplicates.
+// See Mike Seymour in magic-numbers-in-boosthash-combine:
+//     http://stackoverflow.com/questions/4948780
+
+template <class T>
+inline void hash_combine(std::size_t& seed, T const& v) {
+  seed ^= std::hash<T>()(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+}
+
+// Recursive template code derived from Matthieu M.
+template <class Tuple, size_t Index = std::tuple_size<Tuple>::value - 1>
+struct HashValueImpl {
+  static void apply(size_t& seed, Tuple const& tuple) {
+    HashValueImpl<Tuple, Index - 1>::apply(seed, tuple);
+    hash_combine(seed, std::get<Index>(tuple));
   }
 };
 
-}
+template <class Tuple>
+struct HashValueImpl<Tuple, 0> {
+  static void apply(size_t& seed, Tuple const& tuple) {
+    hash_combine(seed, std::get<0>(tuple));
+  }
+};
+} // namespace
+
+template <typename... TT>
+struct hash<std::tuple<TT...>> {
+  size_t operator()(std::tuple<TT...> const& tt) const {
+    size_t seed = 0;
+    HashValueImpl<std::tuple<TT...>>::apply(seed, tt);
+    return seed;
+  }
+};
+} // namespace std
 
 #endif /*INCLUDED_VT_UTILS_HASH_HASH_TUPLE_H*/
diff --git a/tests/perf/allreduce.cc b/tests/perf/allreduce.cc
new file mode 100644
index 0000000000..2ea024ab7a
--- /dev/null
+++ b/tests/perf/allreduce.cc
@@ -0,0 +1,259 @@
+/*
+//@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/operators/functors/plus_op.h"
+#include "vt/configs/error/config_assert.h"
+#include "vt/context/context.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>
+
+#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();
+  }
+
+  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_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_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);
+    Kokkos::parallel_for(
+      "InitView", view.extent(0),
+      KOKKOS_LAMBDA(const int 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"
+  );
+
+  using DataT = decltype(data);
+  using Reducer = collective::reduce::allreduce::Rabenseifner<
+    DataT, collective::PlusOp, NodeObj<MyTest>, &NodeObj<MyTest>::handlerVec>;
+
+  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));
+    theObjGroup()->allreduce<Reducer>(proxy, 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"
+  );
+
+  using DataT = decltype(view);
+  using Reducer = collective::reduce::allreduce::Rabenseifner<
+    DataT, collective::PlusOp, NodeObj<MyTestKokkos>,
+    &NodeObj<MyTestKokkos>::handlerView<float>
+  >;
+
+  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));
+    theObjGroup()->allreduce<Reducer>(proxy, 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"
+  );
+
+  using DataT = decltype(data);
+  using Reducer = collective::reduce::allreduce::RecursiveDoubling<
+    DataT, collective::PlusOp, NodeObj<MyTest>, &NodeObj<MyTest>::handlerVec>;
+
+  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));
+    theObjGroup()->allreduce<Reducer>(proxy, 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"
+  );
+
+  using DataT = decltype(view);
+  using Reducer = collective::reduce::allreduce::RecursiveDoubling<
+    DataT, collective::PlusOp, NodeObj<MyTestKokkos>,
+    &NodeObj<MyTestKokkos>::handlerView<float>
+  >;
+
+  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));
+    theObjGroup()->allreduce<Reducer>(proxy, view);
+
+    theSched()->runSchedulerWhile([obj_ptr] { return !obj_ptr->allreduce_done_; });
+    obj_ptr->allreduce_done_ = false;
+  }
+}
+#endif // MAGISTRATE_KOKKOS_ENABLED
+
+VT_PERF_TEST_MAIN()
diff --git a/tests/perf/common/test_harness_macros.h b/tests/perf/common/test_harness_macros.h
index bb668cfe26..52e1817eb9 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/reduce.cc b/tests/perf/reduce.cc
index edda6c8a3d..4ab9147b07 100644
--- a/tests/perf/reduce.cc
+++ b/tests/perf/reduce.cc
@@ -50,7 +50,7 @@
 using namespace vt;
 using namespace vt::tests::perf::common;
 
-static constexpr int num_iters = 100;
+static constexpr int num_iters = 1;
 
 struct MyTest : PerfTestHarness {
   MyTest() { DisableGlobalTimer(); }
diff --git a/tests/unit/objgroup/test_objgroup.cc b/tests/unit/objgroup/test_objgroup.cc
index ddfc690cd0..6f96002693 100644
--- a/tests/unit/objgroup/test_objgroup.cc
+++ b/tests/unit/objgroup/test_objgroup.cc
@@ -43,10 +43,16 @@
 
 #include "test_objgroup_common.h"
 #include "test_helpers.h"
+#include "vt/collective/reduce/allreduce/rabenseifner.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 +262,112 @@ 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_h<&MyObjA::verifyAllred<1>, PlusOp>(my_node); }
+  );
+
+  EXPECT_EQ(MyObjA::total_verify_expected_, 1);
+
+  runInEpochCollective(
+    [&] { proxy.allreduce_h<&MyObjA::verifyAllred<2>, PlusOp>(4); }
+  );
+
+  EXPECT_EQ(MyObjA::total_verify_expected_, 2);
+
+  runInEpochCollective(
+    [&] { proxy.allreduce_h<&MyObjA::verifyAllred<3>, MaxOp>(my_node); }
+  );
+
+  EXPECT_EQ(MyObjA::total_verify_expected_, 3);
+  runInEpochCollective([&] {
+    using Reducer = vt::collective::reduce::allreduce::RecursiveDoubling<
+      std::vector<int>, PlusOp, MyObjA, &MyObjA::verifyAllredVec<int, 256>
+    >;
+    std::vector<int> payload(256, my_node);
+    theObjGroup()->allreduce<Reducer>(proxy, payload);
+  });
+
+  EXPECT_EQ(MyObjA::total_verify_expected_, 4);
+
+  runInEpochCollective([&] {
+    using Reducer = vt::collective::reduce::allreduce::Rabenseifner<
+      NodeType, PlusOp, MyObjA, &MyObjA::verifyAllred<1>
+    >;
+    std::vector<int> payload(2048, my_node);
+    theObjGroup()->allreduce<Reducer>(proxy, my_node);
+
+    std::vector<short> payload_large(2048 * 2, my_node);
+    theObjGroup()->allreduce<Reducer>(proxy, my_node);
+  });
+
+  EXPECT_EQ(MyObjA::total_verify_expected_, 6);
+
+  runInEpochCollective([&] {
+    using Reducer = vt::collective::reduce::allreduce::Rabenseifner<
+      VectorPayload, PlusOp, MyObjA, &MyObjA::verifyAllredVecPayload<VectorPayload, 256>>;
+    std::vector<int> payload(256, my_node);
+    VectorPayload data{payload};
+    theObjGroup()->allreduce<Reducer>(proxy, 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;
+
+  TestObjGroup::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);
+    Kokkos::parallel_for(
+      "InitView", view.extent(0),
+      KOKKOS_LAMBDA(const int i) { view(i) = static_cast<float>(my_node); });
+
+    using Reducer = vt::collective::reduce::allreduce::Rabenseifner<
+      decltype(view), PlusOp, MyObjA, &MyObjA::verifyAllredView>;
+
+    theObjGroup()->allreduce<Reducer>(kokkos_proxy, 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 67acfd2a3e..3d1848b6fb 100644
--- a/tests/unit/objgroup/test_objgroup_common.h
+++ b/tests/unit/objgroup/test_objgroup_common.h
@@ -46,8 +46,10 @@
 
 #include "test_parallel_harness.h"
 #include "vt/collective/reduce/operators/default_msg.h"
+#include "vt/collective/reduce/allreduce/data_handler.h"
 
 #include <numeric>
+#include <vector>
 
 namespace vt { namespace tests { namespace unit {
 
@@ -57,6 +59,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 +117,54 @@ 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> 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
+  void verifyAllredView(Kokkos::View<float*, Kokkos::HostSpace> 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;
+    Kokkos::parallel_for("InitView", view.extent(0), KOKKOS_LAMBDA(const int i) {
+      EXPECT_EQ(view(i), total_sum);
+    });
+
+    total_verify_expected_++;
+  }
+#endif // MAGISTRATE_KOKKOS_ENABLED
+
   int id_ = -1;
   int recv_ = 0;
   static int next_id;
@@ -136,26 +204,26 @@ 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;
-  }
+/*static*/ int MyObjA::next_id = 0;
+/*static*/ int MyObjB::next_id = 0;
+}}} // end namespace vt::tests::unit
 
-  template <typename SerializerT>
-  void serialize(SerializerT& s) {
-    s | vec_;
+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}; }
+  static DataT fromMemory(const Scalar* data, size_t count) {
+    return DataT{std::vector<Scalar>(data, data + count)};
   }
-
-  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
 
 #endif /*INCLUDED_UNIT_OBJGROUP_TEST_OBJGROUP_COMMON_H*/