diff --git a/linkerd/app/core/src/control.rs b/linkerd/app/core/src/control.rs
index 45b472d221..48633d7e7a 100644
--- a/linkerd/app/core/src/control.rs
+++ b/linkerd/app/core/src/control.rs
@@ -71,12 +71,7 @@ impl Config {
         identity: identity::NewClient,
     ) -> svc::ArcNewService<
         (),
-        impl svc::Service<
-                http::Request<tonic::body::BoxBody>,
-                Response = http::Response<RspBody>,
-                Error = ControlError,
-                Future = impl Send,
-            > + Clone,
+        svc::BoxCloneSyncService<http::Request<tonic::body::BoxBody>, http::Response<RspBody>>,
     > {
         let addr = self.addr;
 
@@ -135,6 +130,7 @@ impl Config {
             .push(svc::NewMapErr::layer_from_target::<ControlError, _>())
             .instrument(|c: &ControlAddr| info_span!("controller", addr = %c.addr))
             .push_map_target(move |()| addr.clone())
+            .push_on_service(svc::BoxCloneSyncService::layer())
             .push(svc::ArcNewService::layer())
             .into_inner()
     }
diff --git a/linkerd/app/core/src/svc.rs b/linkerd/app/core/src/svc.rs
index 8b075c88c8..bee41fbfb7 100644
--- a/linkerd/app/core/src/svc.rs
+++ b/linkerd/app/core/src/svc.rs
@@ -34,7 +34,7 @@ pub type BoxHttp<B = http::BoxBody> =
 pub type ArcNewHttp<T, B = http::BoxBody> = ArcNewService<T, BoxHttp<B>>;
 
 pub type BoxCloneHttp<B = http::BoxBody> =
-    BoxCloneService<http::Request<B>, http::Response<http::BoxBody>, Error>;
+    BoxCloneSyncService<http::Request<B>, http::Response<http::BoxBody>>;
 
 pub type ArcNewCloneHttp<T, B = http::BoxBody> = ArcNewService<T, BoxCloneHttp<B>>;
 
@@ -42,7 +42,7 @@ pub type BoxTcp<I> = BoxService<I, (), Error>;
 
 pub type ArcNewTcp<T, I> = ArcNewService<T, BoxTcp<I>>;
 
-pub type BoxCloneTcp<I> = BoxCloneService<I, (), Error>;
+pub type BoxCloneTcp<I> = BoxCloneSyncService<I, ()>;
 
 pub type ArcNewCloneTcp<T, I> = ArcNewService<T, BoxCloneTcp<I>>;
 
@@ -302,11 +302,25 @@ impl<S> Stack<S> {
         T: 'static,
         B: 'static,
         S: NewService<T, Service = Svc> + Send + Sync + 'static,
-        Svc: Service<http::Request<B>, Response = http::Response<http::BoxBody>, Error = Error>,
-        Svc: Clone + Send + 'static,
+        Svc: Service<http::Request<B>, Response = http::Response<http::BoxBody>>,
+        Svc: Clone + Send + Sync + 'static,
+        Svc::Error: Into<Error>,
+        Svc::Future: Send,
+    {
+        self.push_on_service(BoxCloneHttp::layer())
+            .push(ArcNewService::layer())
+    }
+
+    pub fn arc_new_clone_tcp<T, I, Svc>(self) -> Stack<ArcNewCloneTcp<T, I>>
+    where
+        T: 'static,
+        I: 'static,
+        S: NewService<T, Service = Svc> + Send + Sync + 'static,
+        Svc: Service<I, Response = ()> + Clone + Send + Sync + 'static,
+        Svc::Error: Into<Error>,
         Svc::Future: Send,
     {
-        self.push_on_service(BoxCloneService::layer())
+        self.push_on_service(BoxCloneTcp::layer())
             .push(ArcNewService::layer())
     }
 
diff --git a/linkerd/app/inbound/src/http/router.rs b/linkerd/app/inbound/src/http/router.rs
index db4b5ed696..76274a4abb 100644
--- a/linkerd/app/inbound/src/http/router.rs
+++ b/linkerd/app/inbound/src/http/router.rs
@@ -74,7 +74,7 @@ impl<C> Inbound<C> {
             + Param<Remote<ClientAddr>>
             + Param<tls::ConditionalServerTls>
             + Param<policy::AllowPolicy>,
-        T: Clone + Send + Unpin + 'static,
+        T: Clone + Send + Sync + Unpin + 'static,
         P: profiles::GetProfile<Error = Error>,
         C: svc::MakeConnection<Http> + Clone + Send + Sync + Unpin + 'static,
         C::Connection: Send + Unpin,
diff --git a/linkerd/app/inbound/src/http/server.rs b/linkerd/app/inbound/src/http/server.rs
index 69bf43349a..fef0173ff3 100644
--- a/linkerd/app/inbound/src/http/server.rs
+++ b/linkerd/app/inbound/src/http/server.rs
@@ -43,6 +43,7 @@ impl<H> Inbound<H> {
         HSvc: svc::Service<http::Request<http::BoxBody>, Response = http::Response<http::BoxBody>>
             + Clone
             + Send
+            + Sync
             + Unpin
             + 'static,
         HSvc::Error: Into<Error>,
diff --git a/linkerd/app/outbound/src/http/concrete.rs b/linkerd/app/outbound/src/http/concrete.rs
index c2fc6c75a6..8f67f50d32 100644
--- a/linkerd/app/outbound/src/http/concrete.rs
+++ b/linkerd/app/outbound/src/http/concrete.rs
@@ -79,20 +79,7 @@ impl<N> Outbound<N> {
     /// 'failfast'. While in failfast, buffered requests are failed and the
     /// service becomes unavailable so callers may choose alternate concrete
     /// services.
-    pub fn push_http_concrete<T, NSvc, R>(
-        self,
-        resolve: R,
-    ) -> Outbound<
-        svc::ArcNewService<
-            T,
-            impl svc::Service<
-                    http::Request<http::BoxBody>,
-                    Response = http::Response<http::BoxBody>,
-                    Error = Error,
-                    Future = impl Send,
-                > + Clone,
-        >,
-    >
+    pub fn push_http_concrete<T, NSvc, R>(self, resolve: R) -> Outbound<svc::ArcNewCloneHttp<T>>
     where
         // Concrete target type.
         T: svc::Param<ParentRef>,
@@ -157,7 +144,7 @@ impl<N> Outbound<N> {
                 // TODO(ver) Configure this queue from the target (i.e. from
                 // discovery).
                 .push(svc::NewQueue::layer_via(config.http_request_queue))
-                .push(svc::ArcNewService::layer())
+                .arc_new_clone_http()
         })
     }
 }
@@ -182,20 +169,7 @@ where
         config: &crate::Config,
         rt: &crate::Runtime,
         resolve: R,
-    ) -> impl svc::Layer<
-        N,
-        Service = svc::ArcNewService<
-            Self,
-            impl svc::Service<
-                http::Request<http::BoxBody>,
-                Response = http::Response<http::BoxBody>,
-                Error = BalanceError,
-                Future = impl std::future::Future<
-                    Output = Result<http::Response<http::BoxBody>, BalanceError>,
-                > + Send,
-            >,
-        >,
-    > + Clone
+    ) -> impl svc::Layer<N, Service = svc::ArcNewHttp<Self>> + Clone
     where
         // Endpoint resolution.
         R: Resolve<ConcreteAddr, Error = Error, Endpoint = Metadata> + 'static,
@@ -271,7 +245,8 @@ where
                         port = %meta.port().map(u16::from).unwrap_or(0),
                     )
                 })
-                .push(svc::ArcNewService::layer())
+                .push_on_service(svc::MapErr::layer_boxed())
+                .arc_new_http()
                 .into_inner()
         })
     }
diff --git a/linkerd/app/outbound/src/http/logical.rs b/linkerd/app/outbound/src/http/logical.rs
index fd35ced06b..b1005eaaaa 100644
--- a/linkerd/app/outbound/src/http/logical.rs
+++ b/linkerd/app/outbound/src/http/logical.rs
@@ -81,19 +81,7 @@ impl<N> Outbound<N> {
     /// support per-request routing over a set of concrete inner services.
     /// Only available inner services are used for routing. When there are no
     /// available backends, requests are failed with a [`svc::stack::LoadShedError`].
-    pub fn push_http_logical<T, NSvc>(
-        self,
-    ) -> Outbound<
-        svc::ArcNewService<
-            T,
-            impl svc::Service<
-                    http::Request<http::BoxBody>,
-                    Response = http::Response<http::BoxBody>,
-                    Error = Error,
-                    Future = impl Send,
-                > + Clone,
-        >,
-    >
+    pub fn push_http_logical<T, NSvc>(self) -> Outbound<svc::ArcNewCloneHttp<T>>
     where
         // Logical target.
         T: svc::Param<watch::Receiver<Routes>>,
@@ -111,16 +99,13 @@ impl<N> Outbound<N> {
         self.map_stack(|_config, rt, concrete| {
             // For each `T` target, watch its `Profile`, rebuilding a
             // router stack.
-            let watch = concrete
+            concrete
                 // Share the concrete stack with each router stack.
                 .lift_new()
                 .push_on_service(RouterParams::layer(rt.metrics.clone()))
                 // Rebuild the inner router stack every time the watch changes.
-                .push(svc::NewSpawnWatch::<Routes, _>::layer_into::<RouterParams<T>>());
-
-            watch
-                .push_on_service(svc::MapErr::layer_boxed())
-                .push(svc::ArcNewService::layer())
+                .push(svc::NewSpawnWatch::<Routes, _>::layer_into::<RouterParams<T>>())
+                .arc_new_clone_http()
         })
     }
 }
@@ -133,18 +118,7 @@ where
 {
     fn layer<N, S>(
         metrics: OutboundMetrics,
-    ) -> impl svc::Layer<
-        N,
-        Service = svc::ArcNewService<
-            RouterParams<T>,
-            impl svc::Service<
-                    http::Request<http::BoxBody>,
-                    Response = http::Response<http::BoxBody>,
-                    Error = Error,
-                    Future = impl Send,
-                > + Clone,
-        >,
-    > + Clone
+    ) -> impl svc::Layer<N, Service = svc::ArcNewCloneHttp<RouterParams<T>>> + Clone
     where
         N: svc::NewService<Concrete<T>, Service = S>,
         N: Clone + Send + Sync + 'static,
@@ -191,8 +165,7 @@ where
                         .into_inner(),
                 )
                 .push(svc::NewMapErr::layer_from_target::<LogicalError, _>())
-                .push_on_service(svc::MapErr::layer_boxed())
-                .push(svc::ArcNewService::layer())
+                .arc_new_clone_http()
                 .into_inner()
         })
     }
diff --git a/linkerd/app/outbound/src/http/logical/policy.rs b/linkerd/app/outbound/src/http/logical/policy.rs
index 7a79dc6985..de5c41f675 100644
--- a/linkerd/app/outbound/src/http/logical/policy.rs
+++ b/linkerd/app/outbound/src/http/logical/policy.rs
@@ -51,18 +51,7 @@ where
     /// services.
     pub(super) fn layer<N, S>(
         route_backend_metrics: RouteBackendMetrics,
-    ) -> impl svc::Layer<
-        N,
-        Service = svc::ArcNewService<
-            Self,
-            impl svc::Service<
-                    http::Request<http::BoxBody>,
-                    Response = http::Response<http::BoxBody>,
-                    Error = Error,
-                    Future = impl Send,
-                > + Clone,
-        >,
-    > + Clone
+    ) -> impl svc::Layer<N, Service = svc::ArcNewCloneHttp<Self>> + Clone
     where
         // Inner stack.
         N: svc::NewService<Concrete<T>, Service = S>,
@@ -89,7 +78,7 @@ where
                 },
                 grpc.into_inner(),
             )
-            .push(svc::ArcNewService::layer())
+            .arc_new_clone_http()
             .into_inner()
         })
     }
diff --git a/linkerd/app/outbound/src/http/logical/policy/route.rs b/linkerd/app/outbound/src/http/logical/policy/route.rs
index 864e2b3661..803ebfa664 100644
--- a/linkerd/app/outbound/src/http/logical/policy/route.rs
+++ b/linkerd/app/outbound/src/http/logical/policy/route.rs
@@ -84,18 +84,7 @@ where
     /// backends are expected to be cached/shared by the inner stack.
     pub(crate) fn layer<N, S>(
         backend_metrics: backend::RouteBackendMetrics,
-    ) -> impl svc::Layer<
-        N,
-        Service = svc::ArcNewService<
-            Self,
-            impl svc::Service<
-                    http::Request<http::BoxBody>,
-                    Response = http::Response<http::BoxBody>,
-                    Error = Error,
-                    Future = impl Send,
-                > + Clone,
-        >,
-    > + Clone
+    ) -> impl svc::Layer<N, Service = svc::ArcNewCloneHttp<Self>> + Clone
     where
         // Inner stack.
         N: svc::NewService<Concrete<T>, Service = S>,
@@ -126,14 +115,12 @@ where
                 .push(classify::NewClassify::layer())
                 .push(svc::NewMapErr::layer_with(|rt: &Self| {
                     let route = rt.params.route_ref.clone();
-                    move |source| {
-                        Error::from(RouteError {
-                            route: route.clone(),
-                            source,
-                        })
+                    move |source| RouteError {
+                        route: route.clone(),
+                        source,
                     }
                 }))
-                .push(svc::ArcNewService::layer())
+                .arc_new_clone_http()
                 .into_inner()
         })
     }
diff --git a/linkerd/app/outbound/src/http/logical/policy/route/backend.rs b/linkerd/app/outbound/src/http/logical/policy/route/backend.rs
index f790f14b85..0d4bbf0a84 100644
--- a/linkerd/app/outbound/src/http/logical/policy/route/backend.rs
+++ b/linkerd/app/outbound/src/http/logical/policy/route/backend.rs
@@ -85,18 +85,7 @@ where
     /// filters.
     pub(crate) fn layer<N, S>(
         metrics: RouteBackendMetrics,
-    ) -> impl svc::Layer<
-        N,
-        Service = svc::ArcNewService<
-            Self,
-            impl svc::Service<
-                    http::Request<http::BoxBody>,
-                    Response = http::Response<http::BoxBody>,
-                    Error = Error,
-                    Future = impl Send,
-                > + Clone,
-        >,
-    > + Clone
+    ) -> impl svc::Layer<N, Service = svc::ArcNewCloneHttp<Self>> + Clone
     where
         // Inner stack.
         N: svc::NewService<Concrete<T>, Service = S>,
@@ -131,7 +120,7 @@ where
                         })
                     }
                 }))
-                .push(svc::ArcNewService::layer())
+                .arc_new_clone_http()
                 .into_inner()
         })
     }
diff --git a/linkerd/app/outbound/src/http/logical/policy/router.rs b/linkerd/app/outbound/src/http/logical/policy/router.rs
index e2d39d8a6c..2262e9640e 100644
--- a/linkerd/app/outbound/src/http/logical/policy/router.rs
+++ b/linkerd/app/outbound/src/http/logical/policy/router.rs
@@ -71,18 +71,7 @@ where
     /// set of inner services so that.
     pub(super) fn layer<N, S>(
         route_backend_metrics: RouteBackendMetrics,
-    ) -> impl svc::Layer<
-        N,
-        Service = svc::ArcNewService<
-            Self,
-            impl svc::Service<
-                    http::Request<http::BoxBody>,
-                    Response = http::Response<http::BoxBody>,
-                    Error = Error,
-                    Future = impl Send,
-                > + Clone,
-        >,
-    > + Clone
+    ) -> impl svc::Layer<N, Service = svc::ArcNewCloneHttp<Self>> + Clone
     where
         // Inner stack.
         N: svc::NewService<Concrete<T>, Service = S>,
@@ -105,7 +94,7 @@ where
                 // `SelectRoute` impl.
                 .push_on_service(route::MatchedRoute::layer(route_backend_metrics.clone()))
                 .push(svc::NewOneshotRoute::<Self, (), _>::layer_cached())
-                .push(svc::ArcNewService::layer())
+                .arc_new_clone_http()
                 .into_inner()
         })
     }
diff --git a/linkerd/app/outbound/src/http/logical/profile.rs b/linkerd/app/outbound/src/http/logical/profile.rs
index 8bdfa6db96..897e95e0e9 100644
--- a/linkerd/app/outbound/src/http/logical/profile.rs
+++ b/linkerd/app/outbound/src/http/logical/profile.rs
@@ -69,18 +69,7 @@ where
     /// we can reuse inner services.
     pub(super) fn layer<N, S>(
         metrics: metrics::Proxy,
-    ) -> impl svc::Layer<
-        N,
-        Service = svc::ArcNewService<
-            Self,
-            impl svc::Service<
-                    http::Request<http::BoxBody>,
-                    Response = http::Response<http::BoxBody>,
-                    Error = Error,
-                    Future = impl Send,
-                > + Clone,
-        >,
-    > + Clone
+    ) -> impl svc::Layer<N, Service = svc::ArcNewCloneHttp<Self>> + Clone
     where
         N: svc::NewService<Concrete<T>, Service = S> + Clone + Send + Sync + 'static,
         S: svc::Service<
@@ -101,7 +90,7 @@ where
                 // returned from the `SelectRoute` impl.
                 .push_on_service(RouteParams::layer(metrics.clone()))
                 .push(svc::NewOneshotRoute::<Params<T>, _, _>::layer_cached())
-                .push(svc::ArcNewService::layer())
+                .arc_new_clone_http()
                 .into_inner()
         })
     }
@@ -257,18 +246,7 @@ where
 impl<T> RouteParams<T> {
     fn layer<N, S>(
         metrics: metrics::Proxy,
-    ) -> impl svc::Layer<
-        N,
-        Service = svc::ArcNewService<
-            Self,
-            impl svc::Service<
-                    http::Request<http::BoxBody>,
-                    Response = http::Response<http::BoxBody>,
-                    Error = Error,
-                    Future = impl Send,
-                > + Clone,
-        >,
-    > + Clone
+    ) -> impl svc::Layer<N, Service = svc::ArcNewCloneHttp<Self>> + Clone
     where
         T: Clone + Debug + Eq + Hash + Send + Sync + 'static,
         N: svc::NewService<Concrete<T>, Service = S> + Clone + Send + Sync + 'static,
@@ -329,7 +307,7 @@ impl<T> RouteParams<T> {
                 // extension.
                 .push(classify::NewClassify::layer())
                 .push_on_service(http::BoxResponse::layer())
-                .push(svc::ArcNewService::layer())
+                .arc_new_clone_http()
                 .into_inner()
         })
     }
diff --git a/linkerd/app/outbound/src/opaq.rs b/linkerd/app/outbound/src/opaq.rs
index c3961907dc..bc56f6e444 100644
--- a/linkerd/app/outbound/src/opaq.rs
+++ b/linkerd/app/outbound/src/opaq.rs
@@ -26,15 +26,7 @@ impl<C> Outbound<C> {
     ///
     /// This stack uses caching so that a router/load-balancer may be reused
     /// across multiple connections.
-    pub fn push_opaq_cached<T, I, R>(
-        self,
-        resolve: R,
-    ) -> Outbound<
-        svc::ArcNewService<
-            T,
-            impl svc::Service<I, Response = (), Error = Error, Future = impl Send> + Clone,
-        >,
-    >
+    pub fn push_opaq_cached<T, I, R>(self, resolve: R) -> Outbound<svc::ArcNewCloneTcp<T, I>>
     where
         // Opaque target
         T: svc::Param<Logical>,
@@ -58,7 +50,7 @@ impl<C> Outbound<C> {
                     // Use a dedicated target type to configure parameters for
                     // the opaque stack. It also helps narrow the cache key.
                     .push_map_target(|t: T| Opaq(t.param()))
-                    .push(svc::ArcNewService::layer())
+                    .arc_new_clone_tcp()
             })
     }
 }
diff --git a/linkerd/app/outbound/src/opaq/logical.rs b/linkerd/app/outbound/src/opaq/logical.rs
index 78e980c55f..95cc517cd3 100644
--- a/linkerd/app/outbound/src/opaq/logical.rs
+++ b/linkerd/app/outbound/src/opaq/logical.rs
@@ -74,14 +74,7 @@ impl<N> Outbound<N> {
     /// services. Only available inner services are used for routing. When
     /// there are no available backends, requests are failed with a
     /// [`svc::stack::LoadShedError`].
-    pub fn push_opaq_logical<T, I, NSvc>(
-        self,
-    ) -> Outbound<
-        svc::ArcNewService<
-            T,
-            impl svc::Service<I, Response = (), Error = Error, Future = impl Send> + Clone,
-        >,
-    >
+    pub fn push_opaq_logical<T, I, NSvc>(self) -> Outbound<svc::ArcNewCloneTcp<T, I>>
     where
         // Opaque logical target.
         T: svc::Param<Logical>,
@@ -142,7 +135,7 @@ impl<N> Outbound<N> {
                     },
                     concrete.into_inner(),
                 )
-                .push(svc::ArcNewService::layer())
+                .arc_new_clone_tcp()
         })
     }
 }
diff --git a/linkerd/stack/src/box_future.rs b/linkerd/stack/src/box_future.rs
index 4285df2dff..a55fef2f4a 100644
--- a/linkerd/stack/src/box_future.rs
+++ b/linkerd/stack/src/box_future.rs
@@ -17,7 +17,7 @@ impl<T> BoxFuture<T> {
         Self(inner)
     }
 
-    pub fn layer() -> impl tower::Layer<T, Service = Self> {
+    pub fn layer() -> impl tower::Layer<T, Service = Self> + Copy {
         crate::layer::mk(Self::new)
     }
 }
diff --git a/linkerd/stack/src/box_service.rs b/linkerd/stack/src/box_service.rs
index 929a74de5b..9ab096a524 100644
--- a/linkerd/stack/src/box_service.rs
+++ b/linkerd/stack/src/box_service.rs
@@ -1,37 +1,97 @@
-use std::marker::PhantomData;
+use linkerd_error::{Error, Result};
+use std::{
+    future::Future,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
 pub use tower::util::BoxService;
 
-#[derive(Copy, Debug)]
-pub struct BoxServiceLayer<R> {
-    _p: PhantomData<fn(R)>,
+pub struct BoxCloneSyncService<Req, Rsp> {
+    inner: Box<dyn sealed::BoxCloneSyncService<Req, Rsp, Error = Error>>,
+}
+
+impl<Req, Rsp> BoxCloneSyncService<Req, Rsp> {
+    pub fn new<S>(inner: S) -> Self
+    where
+        S: crate::Service<Req, Response = Rsp> + Send + Sync + Clone + 'static,
+        S::Error: Into<Error>,
+        S::Future: Send + 'static,
+    {
+        Self {
+            inner: Box::new(crate::BoxFuture::new(crate::MapErrBoxed::from(inner))),
+        }
+    }
+
+    pub fn layer<S>() -> impl crate::layer::Layer<S, Service = Self> + Copy
+    where
+        S: crate::Service<Req, Response = Rsp> + Send + Sync + Clone + 'static,
+        S::Error: Into<Error>,
+        S::Future: Send + 'static,
+    {
+        crate::layer::mk(Self::new)
+    }
 }
 
-impl<S, R> tower::Layer<S> for BoxServiceLayer<R>
+impl<Req, Rsp> crate::Service<Req> for BoxCloneSyncService<Req, Rsp>
 where
-    S: tower::Service<R> + Send + 'static,
-    S::Future: Send + 'static,
-    S::Error: Send + 'static,
+    Req: Send + 'static,
 {
-    type Service = BoxService<R, S::Response, S::Error>;
-    fn layer(&self, s: S) -> Self::Service {
-        BoxService::new(s)
+    type Response = Rsp;
+    type Error = Error;
+    type Future = Pin<Box<dyn Future<Output = Result<Rsp>> + Send>>;
+
+    #[inline]
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.inner.poll_ready(cx)
     }
-}
 
-impl<R> BoxServiceLayer<R> {
-    pub fn new() -> Self {
-        Self { _p: PhantomData }
+    #[inline]
+    fn call(&mut self, req: Req) -> Self::Future {
+        self.inner.call(req)
     }
 }
 
-impl<R> Clone for BoxServiceLayer<R> {
+impl<Req, Rsp> Clone for BoxCloneSyncService<Req, Rsp> {
     fn clone(&self) -> Self {
-        Self::new()
+        Self {
+            inner: self.inner.box_clone_sync(),
+        }
     }
 }
 
-impl<R> Default for BoxServiceLayer<R> {
-    fn default() -> Self {
-        Self::new()
+mod sealed {
+    use crate::Service;
+    use linkerd_error::{Error, Result};
+    use std::{future::Future, pin::Pin};
+
+    pub trait BoxCloneSyncService<Req, Rsp>:
+        Service<
+            Req,
+            Response = Rsp,
+            Error = Error,
+            Future = Pin<Box<dyn Future<Output = Result<Rsp>> + Send>>,
+        > + Send
+        + Sync
+    {
+        fn box_clone_sync(&self) -> Box<dyn BoxCloneSyncService<Req, Rsp>>;
+    }
+
+    // Implement the trait for Box<dyn YourTrait>
+    impl<Req, Rsp, S> BoxCloneSyncService<Req, Rsp> for S
+    where
+        S: Service<
+                Req,
+                Error = Error,
+                Response = Rsp,
+                Future = Pin<Box<dyn Future<Output = Result<Rsp>> + Send>>,
+            > + Clone
+            + Send
+            + Sync
+            + 'static,
+    {
+        fn box_clone_sync(&self) -> Box<dyn BoxCloneSyncService<Req, Rsp>> {
+            Box::new(self.clone())
+        }
     }
 }
diff --git a/linkerd/stack/src/lib.rs b/linkerd/stack/src/lib.rs
index b419d03c47..9905420f46 100644
--- a/linkerd/stack/src/lib.rs
+++ b/linkerd/stack/src/lib.rs
@@ -33,7 +33,7 @@ mod watch;
 pub use self::{
     arc_new_service::ArcNewService,
     box_future::BoxFuture,
-    box_service::{BoxService, BoxServiceLayer},
+    box_service::{BoxCloneSyncService, BoxService},
     connect::{MakeConnection, WithoutConnectionMetadata},
     either::{Either, NewEither},
     fail::Fail,
@@ -59,7 +59,7 @@ pub use self::{
 };
 pub use tower::{
     service_fn,
-    util::{self, future_service, BoxCloneService, FutureService, Oneshot, ServiceExt},
+    util::{self, future_service, FutureService, Oneshot, ServiceExt},
     Service,
 };