diff --git a/src/vt/serialization/sizer.h b/src/vt/serialization/sizer.h
index c8cd26b0e6..35ca714e00 100644
--- a/src/vt/serialization/sizer.h
+++ b/src/vt/serialization/sizer.h
@@ -62,9 +62,7 @@ struct MsgSizer<
   MsgT,
   typename std::enable_if_t<true
     and ::vt::messaging::msg_defines_serialize_mode<MsgT>::value
-    and (::vt::messaging::msg_serialization_mode<MsgT>::supported
-         or ::vt::messaging::msg_serialization_mode<MsgT>::required)
-    //    ::vt::messaging::has_own_serialize<MsgT>
+    and ::vt::messaging::msg_serialization_mode<MsgT>::required
   >
 > {
   static std::size_t get(MsgT* msg) {
diff --git a/src/vt/topos/location/location.h b/src/vt/topos/location/location.h
index 761cb52701..fec0849067 100644
--- a/src/vt/topos/location/location.h
+++ b/src/vt/topos/location/location.h
@@ -229,24 +229,21 @@ struct EntityLocationCoord : LocationCoord {
    *
    * \param[in] id the entity ID
    * \param[in] home_node home node for entity
-   * \param[in] m pointer to the message
+   * \param[in] m message shared pointer
    */
   template <typename MessageT, ActiveTypedFnType<MessageT> *f>
   void routeMsgHandler(
-    EntityID const& id, NodeType const& home_node, MessageT *m
+    EntityID const& id, NodeType const& home_node,
+    MsgSharedPtr<MessageT> const& msg
   );
 
   /**
-   * \brief Route a serialized message with a custom handler
+   * \brief Route a message with a custom handler where the element is local
    *
-   * \param[in] id the entity ID
-   * \param[in] home_node home node for entity
-   * \param[in] msg pointer to the message
+   * \param[in] m message shared pointer
    */
-  template <typename MessageT, ActiveTypedFnType<MessageT> *f>
-  void routeMsgSerializeHandler(
-    EntityID const& id, NodeType const& home_node, MsgSharedPtr<MessageT> msg
-  );
+  template <typename MessageT>
+  void routeMsgHandlerLocal(MsgSharedPtr<MessageT> const& msg);
 
   /**
    * \brief Route a message to the default handler
@@ -254,28 +251,15 @@ struct EntityLocationCoord : LocationCoord {
    * \param[in] id the entity ID
    * \param[in] home_node home node for the entity
    * \param[in] msg pointer to the message
-   * \param[in] serialize_msg whether it should be serialized (optional)
    * \param[in] from_node the sending node (optional)
    */
   template <typename MessageT>
   void routeMsg(
-    EntityID const& id, NodeType const& home_node, MsgSharedPtr<MessageT> msg,
-    bool const serialize_msg = false,
+    EntityID const& id, NodeType const& home_node,
+    MsgSharedPtr<MessageT> const& msg,
     NodeType from_node = uninitialized_destination
   );
 
-  /**
-   * \brief  Route a message to the default handler
-   *
-   * \param[in] id the entity ID
-   * \param[in] home_node home node for the entity
-   * \param[in] msg pointer to the message
-   */
-  template <typename MessageT>
-  void routeMsgSerialize(
-    EntityID const& id, NodeType const& home_node, MsgSharedPtr<MessageT> msg
-  );
-
   /**
    * \internal \brief Route a message with non-eager protocol
    *
@@ -357,7 +341,7 @@ struct EntityLocationCoord : LocationCoord {
    * \return whether it is of eager size
    */
   template <typename MessageT>
-  bool useEagerProtocol(MsgSharedPtr<MessageT> msg) const;
+  bool useEagerProtocol(MsgSharedPtr<MessageT> const& msg) const;
 
 private:
   /**
@@ -392,21 +376,19 @@ struct EntityLocationCoord : LocationCoord {
   /**
    * \internal \brief Route a message to destination with eager protocol
    *
-   * \param[in] is_serialized whether it is serialized
    * \param[in] id the entity ID
    * \param[in] home_node the home node
    * \param[in] msg the message to route
    */
   template <typename MessageT>
   void routeMsgEager(
-    bool const is_serialized, EntityID const& id, NodeType const& home_node,
-    MsgSharedPtr<MessageT> msg
+    EntityID const& id, NodeType const& home_node,
+    MsgSharedPtr<MessageT> const& msg
   );
 
   /**
    * \internal \brief Route a message to destination with rendezvous protocol
    *
-   * \param[in] is_serialized whether it is serialized
    * \param[in] id the entity ID
    * \param[in] home_node the home node
    * \param[in] to_node destination node
@@ -414,8 +396,8 @@ struct EntityLocationCoord : LocationCoord {
    */
   template <typename MessageT>
   void routeMsgNode(
-    bool const is_serialized, EntityID const& id, NodeType const& home_node,
-    NodeType const& to_node, MsgSharedPtr<MessageT> msg
+    EntityID const& id, NodeType const& home_node, NodeType const& to_node,
+    MsgSharedPtr<MessageT> const& msg
   );
 
   /**
diff --git a/src/vt/topos/location/location.impl.h b/src/vt/topos/location/location.impl.h
index bb3c4ad407..22fff5a6ab 100644
--- a/src/vt/topos/location/location.impl.h
+++ b/src/vt/topos/location/location.impl.h
@@ -277,14 +277,37 @@ void EntityLocationCoord<EntityID>::clearCache() {
   recs_.clearCache();
 }
 
+namespace detail {
+
+template <typename MsgT, typename=void>
+struct IsSerializable {
+  static constexpr bool const is_ser = false;
+};
+
+template <typename MsgT>
+struct IsSerializable<
+  MsgT,
+  typename std::enable_if_t<true
+    and ::vt::messaging::msg_defines_serialize_mode<MsgT>::value
+    and ::vt::messaging::msg_serialization_mode<MsgT>::required
+  >
+>
+{
+  static constexpr bool const is_ser = true;
+};
+
+} /* end namespace detail */
+
 template <typename EntityID>
 template <typename MessageT>
-bool EntityLocationCoord<EntityID>::useEagerProtocol(MsgSharedPtr<MessageT> msg) const {
-
-  bool const is_small = sizeof(*msg) < small_msg_max_size;
-  bool const is_serialized = msg->getSerialize();
-  // could change according to entity type or another criterion
-  return is_small and not is_serialized;
+bool EntityLocationCoord<EntityID>::useEagerProtocol(
+  MsgSharedPtr<MessageT> const& msg
+) const {
+  if (detail::IsSerializable<MessageT>::is_ser) {
+    return false;
+  } else {
+    return sizeof(*msg) < small_msg_max_size;
+  }
 }
 
 template <typename EntityID>
@@ -313,8 +336,8 @@ void EntityLocationCoord<EntityID>::insertPendingEntityAction(
 template <typename EntityID>
 template <typename MessageT>
 void EntityLocationCoord<EntityID>::routeMsgEager(
-  bool const is_serialized, EntityID const& id, NodeType const& home_node,
-  MsgSharedPtr<MessageT> msg
+  EntityID const& id, NodeType const& home_node,
+  MsgSharedPtr<MessageT> const& msg
 ) {
   auto const& this_node = theContext()->getNode();
   NodeType route_to_node = uninitialized_destination;
@@ -325,8 +348,8 @@ void EntityLocationCoord<EntityID>::routeMsgEager(
   vt_debug_print(
     normal, location,
     "EntityLocationCoord: routeMsgEager: found={}, home_node={}, "
-    "route_to_node={}, is_serialized={}, id={}\n",
-    found, home_node, route_to_node, is_serialized, id
+    "route_to_node={}, id={}\n",
+    found, home_node, route_to_node, id
   );
 
   if (found) {
@@ -360,11 +383,11 @@ void EntityLocationCoord<EntityID>::routeMsgEager(
   vt_debug_print(
     normal, location,
     "EntityLocationCoord: routeMsgEager: home_node={}, route_node={}, "
-    "is_serialized={}, id={}\n",
-    home_node, route_to_node, is_serialized, id
+    "id={}\n",
+    home_node, route_to_node, id
   );
 
-  return routeMsgNode<MessageT>(is_serialized,id,home_node,route_to_node,msg);
+  return routeMsgNode<MessageT>(id, home_node, route_to_node, msg);
 }
 
 template <typename EntityID>
@@ -481,8 +504,8 @@ void EntityLocationCoord<EntityID>::sendEagerUpdate(
 template <typename EntityID>
 template <typename MessageT>
 void EntityLocationCoord<EntityID>::routeMsgNode(
-  bool const is_serialized, EntityID const& id, NodeType const& home_node,
-  NodeType const& to_node, MsgSharedPtr<MessageT> msg
+  EntityID const& id, NodeType const& home_node, NodeType const& to_node,
+  MsgSharedPtr<MessageT> const& msg
 ) {
   auto const& this_node = theContext()->getNode();
   auto const epoch = theMsg()->getEpochContextMsg(msg);
@@ -490,8 +513,8 @@ void EntityLocationCoord<EntityID>::routeMsgNode(
   vt_debug_print(
     normal, location,
     "EntityLocationCoord: routeMsgNode: to_node={}, this_node={}: inst={}, "
-    "is_serialized={}, home_node={}, id={}, ref={}, from={}, msg={}, epoch={:x}\n",
-    to_node, this_node, this_inst, is_serialized, home_node, id,
+    "home_node={}, id={}, ref={}, from={}, msg={}, epoch={:x}\n",
+    to_node, this_node, this_inst, home_node, id,
     envelopeGetRef(msg->env), msg->getLocFromNode(), print_ptr(msg.get()),
     epoch
   );
@@ -512,8 +535,9 @@ void EntityLocationCoord<EntityID>::routeMsgNode(
     // set the instance on the message to deliver to the correct manager
     msg->setLocInst(this_inst);
 
+    auto m = msg;
     // send to the node discovered by the location manager
-    theMsg()->sendMsg<MessageT, routedHandler>(to_node, msg);
+    theMsg()->sendMsg<MessageT, routedHandler>(to_node, m);
   } else {
     vt_debug_print(
       normal, location,
@@ -609,7 +633,7 @@ void EntityLocationCoord<EntityID>::routeMsgNode(
            *  typically when an non-migrated registration occurs off the home
            *  node and messages are buffered, awaiting forwarding information.
            */
-          routeMsgNode<MessageT>(is_serialized,id_,home_node,resolved,msg);
+          routeMsgNode<MessageT>(id_, home_node, resolved,msg);
         }
         theMsg()->popEpoch(epoch);
         theTerm()->consume(epoch);
@@ -630,7 +654,8 @@ void EntityLocationCoord<EntityID>::routeNonEagerAction(
 template <typename EntityID>
 template <typename MessageT, ActiveTypedFnType<MessageT> *f>
 void EntityLocationCoord<EntityID>::routeMsgHandler(
-  EntityID const& id, NodeType const& home_node, MessageT *m
+  EntityID const& id, NodeType const& home_node,
+  MsgSharedPtr<MessageT> const& msg
 ) {
   using auto_registry::HandlerManagerType;
 
@@ -638,47 +663,34 @@ void EntityLocationCoord<EntityID>::routeMsgHandler(
 
 # if vt_check_enabled(trace_enabled)
   HandlerManagerType::setHandlerTrace(
-    handler, envelopeGetTraceRuntimeEnabled(m->env)
+    handler, envelopeGetTraceRuntimeEnabled(msg->env)
   );
 # endif
 
-  m->setHandler(handler);
-  auto msg = promoteMsg(m);
-  return routeMsg<MessageT>(id,home_node,msg);
-}
-
-template <typename EntityID>
-template <typename MessageT, ActiveTypedFnType<MessageT> *f>
-void EntityLocationCoord<EntityID>::routeMsgSerializeHandler(
-  EntityID const& id, NodeType const& home_node, MsgSharedPtr<MessageT> m
-) {
-  using auto_registry::HandlerManagerType;
-
-  auto handler = auto_registry::makeAutoHandler<MessageT,f>();
+  msg->setHandler(handler);
 
-# if vt_check_enabled(trace_enabled)
-  HandlerManagerType::setHandlerTrace(
-    handler, envelopeGetTraceRuntimeEnabled(m->env)
-  );
-# endif
-
-  m->setHandler(handler);
-  return routeMsg<MessageT>(id,home_node,m,true);
+  if (local_registered_.find(id) == local_registered_.end()) {
+    return routeMsg<MessageT>(id,home_node,msg);
+  } else {
+    return routeMsgHandlerLocal(msg);
+  }
 }
 
 template <typename EntityID>
 template <typename MessageT>
-void EntityLocationCoord<EntityID>::routeMsgSerialize(
-  EntityID const& id, NodeType const& home_node, MsgSharedPtr<MessageT> m
+void EntityLocationCoord<EntityID>::routeMsgHandlerLocal(
+  MsgSharedPtr<MessageT> const& msg
 ) {
-  return routeMsg<MessageT>(id,home_node,m,true);
+  runnable::makeRunnable(msg, true, msg->getHandler(), theContext()->getNode())
+    .withTDEpochFromMsg()
+    .run();
 }
 
 template <typename EntityID>
 template <typename MessageT>
 void EntityLocationCoord<EntityID>::routeMsg(
-  EntityID const& id, NodeType const& home_node, MsgSharedPtr<MessageT> msg,
-  bool const serialize_msg, NodeType from_node
+  EntityID const& id, NodeType const& home_node,
+  MsgSharedPtr<MessageT> const& msg, NodeType from_node
 ) {
   auto const from =
     from_node == uninitialized_destination ? theContext()->getNode() :
@@ -688,7 +700,6 @@ void EntityLocationCoord<EntityID>::routeMsg(
   msg->setEntity(id);
   msg->setHomeNode(home_node);
   msg->setLocFromNode(from);
-  msg->setSerialize(serialize_msg);
 
   auto const msg_size = sizeof(*msg);
   bool const use_eager = useEagerProtocol(msg);
@@ -697,9 +708,9 @@ void EntityLocationCoord<EntityID>::routeMsg(
   vt_debug_print(
     verbose, location,
     "routeMsg: inst={}, home={}, msg_size={}, is_large_msg={}, eager={}, "
-    "serialize_msg={}, in_from={}, from={}, msg{}, msg from={}, epoch={:x}\n",
+    "in_from={}, from={}, msg{}, msg from={}, epoch={:x}\n",
     this_inst, home_node, msg_size, msg_size > small_msg_max_size, use_eager,
-    serialize_msg, from_node, from, print_ptr(msg.get()), msg->getLocFromNode(),
+    from_node, from, print_ptr(msg.get()), msg->getLocFromNode(),
     epoch
   );
 
@@ -707,14 +718,14 @@ void EntityLocationCoord<EntityID>::routeMsg(
 
   if (use_eager) {
     theMsg()->pushEpoch(epoch);
-    routeMsgEager<MessageT>(serialize_msg, id, home_node, msg);
+    routeMsgEager<MessageT>(id, home_node, msg);
     theMsg()->popEpoch(epoch);
   } else {
     theTerm()->produce(epoch);
     // non-eager protocol: get location first then send message after resolution
     getLocation(id, home_node, [=](NodeType node) {
       theMsg()->pushEpoch(epoch);
-      routeMsgNode<MessageT>(serialize_msg, id, home_node, node, msg);
+      routeMsgNode<MessageT>(id, home_node, node, msg);
       theMsg()->popEpoch(epoch);
       theTerm()->consume(epoch);
     });
@@ -787,7 +798,6 @@ template <typename MessageT>
   auto const entity_id = msg->getEntity();
   auto const home_node = msg->getHomeNode();
   auto const inst = msg->getLocInst();
-  auto const is_serialized = msg->getSerialize();
   auto const from_node = msg->getLocFromNode();
   auto const epoch = theMsg()->getEpochContextMsg(msg);
 
@@ -795,9 +805,9 @@ template <typename MessageT>
 
   vt_debug_print(
     verbose, location,
-    "routedHandler: msg={}, ref={}, loc_inst={}, is_serialized={}, id={}, from={}, "
+    "routedHandler: msg={}, ref={}, loc_inst={}, id={}, from={}, "
     "epoch={:x}, hops={}, ask={}\n",
-    print_ptr(msg.get()), envelopeGetRef(msg->env), inst, is_serialized, entity_id,
+    print_ptr(msg.get()), envelopeGetRef(msg->env), inst, entity_id,
     from_node, epoch, msg->getHops(), msg->getAskNode()
   );
 
@@ -805,7 +815,7 @@ template <typename MessageT>
   LocationManager::applyInstance<EntityLocationCoord<EntityID>>(
     inst, [=](EntityLocationCoord<EntityID>* loc) {
       theMsg()->pushEpoch(epoch);
-      loc->routeMsg(entity_id, home_node, msg, is_serialized, from_node);
+      loc->routeMsg(entity_id, home_node, msg, from_node);
       theMsg()->popEpoch(epoch);
       theTerm()->consume(epoch);
     }
diff --git a/src/vt/topos/location/message/msg.h b/src/vt/topos/location/message/msg.h
index 8983ad3e07..d6e53825c8 100644
--- a/src/vt/topos/location/message/msg.h
+++ b/src/vt/topos/location/message/msg.h
@@ -104,8 +104,6 @@ struct EntityMsg : ActiveMessageT {
   bool hasHandler() const { return handler_ != uninitialized_handler; }
   void setHandler(HandlerType const han) { handler_ = han; }
   HandlerType getHandler() const { return handler_; }
-  void setSerialize(bool const is_serialize) { serialize_ = is_serialize; }
-  bool getSerialize() const { return serialize_; }
   void incHops() { hops_ += 1; }
   int16_t getHops() const { return hops_; }
   void setAskNode(NodeType const& node) { ask_node_ = node; }
@@ -119,7 +117,6 @@ struct EntityMsg : ActiveMessageT {
     s | loc_from_node_;
     s | loc_man_inst_;
     s | handler_;
-    s | serialize_;
     s | hops_;
     s | ask_node_;
   }
@@ -130,7 +127,6 @@ struct EntityMsg : ActiveMessageT {
   NodeType loc_from_node_ = uninitialized_destination;
   LocInstType loc_man_inst_ = no_loc_inst;
   HandlerType handler_ = uninitialized_handler;
-  bool serialize_ = false;
   int16_t hops_ = 0;
   NodeType ask_node_ =  uninitialized_destination;
 };
diff --git a/src/vt/vrt/collection/manager.impl.h b/src/vt/vrt/collection/manager.impl.h
index c43e92354c..342a848b32 100644
--- a/src/vt/vrt/collection/manager.impl.h
+++ b/src/vt/vrt/collection/manager.impl.h
@@ -1207,7 +1207,7 @@ messaging::PendingSend CollectionManager::sendMsgUntypedHandler(
       auto lm = theLocMan()->getCollectionLM<IdxT>(col_proxy);
       vtAssert(lm != nullptr, "LM must exist");
       theMsg()->markAsCollectionMessage(msg);
-      lm->template routeMsgSerializeHandler<
+      lm->template routeMsgHandler<
         MsgT, collectionMsgTypedHandler<ColT,IdxT,MsgT>
       >(idx, home_node, msg);
       theMsg()->popEpoch(cur_epoch);
diff --git a/src/vt/vrt/context/context_vrtmanager.impl.h b/src/vt/vrt/context/context_vrtmanager.impl.h
index 6a6bc8a437..381be9ad96 100644
--- a/src/vt/vrt/context/context_vrtmanager.impl.h
+++ b/src/vt/vrt/context/context_vrtmanager.impl.h
@@ -169,7 +169,7 @@ messaging::PendingSend VirtualContextManager::sendSerialMsg(
             innermsg->setProxy(toProxy);
             theLocMan()->vrtContextLoc->routeMsgHandler<
               SerialMsgT, SerializedMessenger::payloadMsgHandler
-            >(toProxy, home_node, innermsg.get());
+            >(toProxy, home_node, innermsg);
             return messaging::PendingSend(nullptr);
           },
           // custom data transfer lambda if above the eager threshold
diff --git a/tests/unit/location/test_location_common.h b/tests/unit/location/test_location_common.h
index d4acc5cdc1..8a7438f6ce 100644
--- a/tests/unit/location/test_location_common.h
+++ b/tests/unit/location/test_location_common.h
@@ -97,9 +97,7 @@ struct LongMsg : vt::LocationRoutedMsg<int, vt::Message> {
 struct SerialMsg : ShortMsg {
   SerialMsg(int in_entity, vt::NodeType in_from)
     : ShortMsg(in_entity, in_from)
-  {
-    setSerialize(true);
-  }
+  { }
 };
 
 template <typename MsgT>
@@ -148,15 +146,13 @@ void verifyCacheConsistency(
   for (int iter = 0; iter < nb_rounds; ++iter) {
     // create an entity message to route
     auto msg = vt::makeMessage<MsgT>(entity, my_node);
-    // check if should be serialized or not
-    bool serialize = msg->getSerialize();
 
     // perform the checks only after all entity messages have been
     // correctly delivered
     runInEpochCollective([&]{
       if (my_node not_eq home) {
         // route entity message
-        vt::theLocMan()->virtual_loc->routeMsg<MsgT>(entity, home, msg, serialize);
+        vt::theLocMan()->virtual_loc->routeMsg<MsgT>(entity, home, msg);
       }
     });
 
@@ -170,8 +166,8 @@ void verifyCacheConsistency(
       vt_debug_print(
         normal, location,
         "verifyCacheConsistency: iter={}, entityID={}, home={}, bytes={}, "
-        "in cache={}, serialize={}\n",
-        iter, entity, msg->from_, sizeof(*msg), is_entity_cached, serialize
+        "in cache={}\n",
+        iter, entity, msg->from_, sizeof(*msg), is_entity_cached
       );
 
       if (not is_eager) {