diff --git a/libs/core/allocator_support/CMakeLists.txt b/libs/core/allocator_support/CMakeLists.txt
index 1e5bcb0f10a..07f9bb77f40 100644
--- a/libs/core/allocator_support/CMakeLists.txt
+++ b/libs/core/allocator_support/CMakeLists.txt
@@ -42,7 +42,7 @@ set(allocator_support_compat_headers
 )
 # cmake-format: on
 
-set(allocator_support_sources)
+set(allocator_support_sources thread_local_caching_allocator.cpp)
 
 include(HPX_AddModule)
 add_hpx_module(
diff --git a/libs/core/allocator_support/include/hpx/allocator_support/thread_local_caching_allocator.hpp b/libs/core/allocator_support/include/hpx/allocator_support/thread_local_caching_allocator.hpp
index 0afd89a7c3f..af8759a7e70 100644
--- a/libs/core/allocator_support/include/hpx/allocator_support/thread_local_caching_allocator.hpp
+++ b/libs/core/allocator_support/include/hpx/allocator_support/thread_local_caching_allocator.hpp
@@ -10,6 +10,7 @@
 #include <hpx/allocator_support/config/defines.hpp>
 
 #include <cstddef>
+#include <functional>
 #include <memory>
 #include <new>
 #include <type_traits>
@@ -21,9 +22,18 @@ namespace hpx::util {
     !((defined(HPX_HAVE_CUDA) && defined(__CUDACC__)) ||                       \
         defined(HPX_HAVE_HIP))
 
+    namespace detail {
+
+        HPX_CORE_EXPORT void init_allocator_cache(
+            std::function<void()>&& clear_cache);
+        HPX_CORE_EXPORT std::pair<void*, std::size_t>
+        allocate_from_cache() noexcept;
+        HPX_CORE_EXPORT [[nodiscard]] bool cache_empty() noexcept;
+        HPX_CORE_EXPORT void return_to_cache(void* p, std::size_t n) noexcept;
+    }    // namespace detail
+
     ///////////////////////////////////////////////////////////////////////////
-    template <template <typename, typename> class Stack, typename T = char,
-        typename Allocator = std::allocator<T>>
+    template <typename T = char, typename Allocator = std::allocator<T>>
     struct thread_local_caching_allocator
     {
         HPX_NO_UNIQUE_ADDRESS Allocator alloc;
@@ -39,7 +49,7 @@ namespace hpx::util {
         template <typename U>
         struct rebind
         {
-            using other = thread_local_caching_allocator<Stack, U,
+            using other = thread_local_caching_allocator<U,
                 typename traits::template rebind_alloc<U>>;
         };
 
@@ -51,91 +61,36 @@ namespace hpx::util {
         using propagate_on_container_swap =
             typename traits::propagate_on_container_swap;
 
-    private:
-        struct allocated_cache
+        explicit thread_local_caching_allocator(
+            Allocator const& alloc = Allocator{}) noexcept(noexcept(std::
+                is_nothrow_copy_constructible_v<Allocator>))
+          : alloc(alloc)
         {
-            explicit allocated_cache(Allocator const& a) noexcept(
-                noexcept(std::is_nothrow_copy_constructible_v<Allocator>))
-              : alloc(a)
-              , data(0)
-            {
-            }
-
-            allocated_cache(allocated_cache const&) = delete;
-            allocated_cache(allocated_cache&&) = delete;
-            allocated_cache& operator=(allocated_cache const&) = delete;
-            allocated_cache& operator=(allocated_cache&&) = delete;
-
-            ~allocated_cache()
-            {
-                clear_cache();
-            }
-
-            pointer allocate(size_type n)
-            {
-                pointer p;
-                std::pair<T*, size_type> pair;
-                if (data.pop(pair))
+            // Note: capturing the allocator will be ok only as long as it
+            // doesn't have any state as this lambda will be possibly called
+            // very late during destruction of the thread_local cache.
+            static_assert(std::is_empty_v<Allocator>,
+                "Please don't use allocators with state in conjunction with "
+                "the thread_local_caching_allocator");
+
+            auto f = [alloc]() mutable {
+                while (!detail::cache_empty())
                 {
-                    p = pair.first;
-                }
-                else
-                {
-                    p = traits::allocate(alloc, n);
-                    if (p == nullptr)
+                    auto [p, n] = detail::allocate_from_cache();
+                    if (p != nullptr)
                     {
-                        throw std::bad_alloc();
+                        traits::deallocate(const_cast<Allocator&>(alloc),
+                            static_cast<char*>(p), n);
                     }
                 }
+            };
 
-                ++allocated;
-                return p;
-            }
-
-            void deallocate(pointer p, size_type n) noexcept
-            {
-                data.push(std::make_pair(p, n));
-                if (++deallocated > 2 * (allocated + 16))
-                {
-                    clear_cache();
-                    allocated = 0;
-                    deallocated = 0;
-                }
-            }
-
-        private:
-            void clear_cache() noexcept
-            {
-                std::pair<T*, size_type> p;
-                while (data.pop(p))
-                {
-                    traits::deallocate(alloc, p.first, p.second);
-                }
-            }
-
-            HPX_NO_UNIQUE_ADDRESS Allocator alloc;
-            Stack<std::pair<T*, size_type>, Allocator> data;
-            std::size_t allocated = 0;
-            std::size_t deallocated = 0;
-        };
-
-        allocated_cache& cache()
-        {
-            thread_local allocated_cache allocated_data(alloc);
-            return allocated_data;
-        }
-
-    public:
-        explicit thread_local_caching_allocator(
-            Allocator const& alloc = Allocator{}) noexcept(noexcept(std::
-                is_nothrow_copy_constructible_v<Allocator>))
-          : alloc(alloc)
-        {
+            detail::init_allocator_cache(HPX_MOVE(f));
         }
 
         template <typename U, typename Alloc>
         explicit thread_local_caching_allocator(
-            thread_local_caching_allocator<Stack, U, Alloc> const&
+            thread_local_caching_allocator<U, Alloc> const&
                 rhs) noexcept(noexcept(std::
                 is_nothrow_copy_constructible_v<Alloc>))
           : alloc(rhs.alloc)
@@ -155,16 +110,28 @@ namespace hpx::util {
 
         [[nodiscard]] pointer allocate(size_type n, void const* = nullptr)
         {
+            n *= sizeof(T);
+
             if (max_size() < n)
             {
                 throw std::bad_array_new_length();
             }
-            return cache().allocate(n);
+
+            auto [p, _] = detail::allocate_from_cache();
+            if (p == nullptr)
+            {
+                p = traits::allocate(alloc, n);
+                if (p == nullptr)
+                {
+                    throw std::bad_alloc();
+                }
+            }
+            return static_cast<pointer>(p);
         }
 
         void deallocate(pointer p, size_type n) noexcept
         {
-            cache().deallocate(p, n);
+            detail::return_to_cache(p, n * sizeof(T));
         }
 
         [[nodiscard]] constexpr size_type max_size() noexcept
@@ -199,8 +166,7 @@ namespace hpx::util {
         }
     };
 #else
-    template <template <typename, typename> class Stack, typename T = char,
-        typename Allocator = std::allocator<T>>
+    template <typename T = char, typename Allocator = std::allocator<T>>
     using thread_local_caching_allocator = Allocator;
 #endif
 }    // namespace hpx::util
diff --git a/libs/core/allocator_support/src/thread_local_caching_allocator.cpp b/libs/core/allocator_support/src/thread_local_caching_allocator.cpp
new file mode 100644
index 00000000000..d7af2a08d3e
--- /dev/null
+++ b/libs/core/allocator_support/src/thread_local_caching_allocator.cpp
@@ -0,0 +1,111 @@
+//  Copyright (c) 2023-2024 Hartmut Kaiser
+//
+//  SPDX-License-Identifier: BSL-1.0
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <hpx/config.hpp>
+#include <hpx/allocator_support/config/defines.hpp>
+
+#if defined(HPX_ALLOCATOR_SUPPORT_HAVE_CACHING) &&                             \
+    !((defined(HPX_HAVE_CUDA) && defined(__CUDACC__)) ||                       \
+        defined(HPX_HAVE_HIP))
+
+#include <hpx/allocator_support/thread_local_caching_allocator.hpp>
+
+#include <cstddef>
+#include <functional>
+#include <stack>
+#include <utility>
+
+namespace hpx::util::detail {
+
+    ///////////////////////////////////////////////////////////////////////////
+    struct allocated_cache
+    {
+        explicit allocated_cache() noexcept = default;
+
+        void init(std::function<void()>&& clear) noexcept
+        {
+            if (!clear_cache)    // initialize once
+            {
+                clear_cache = HPX_MOVE(clear);
+            }
+        }
+
+        allocated_cache(allocated_cache const&) = delete;
+        allocated_cache(allocated_cache&&) = delete;
+        allocated_cache& operator=(allocated_cache const&) = delete;
+        allocated_cache& operator=(allocated_cache&&) = delete;
+
+        ~allocated_cache()
+        {
+            clear_cache();
+        }
+
+        std::pair<void*, std::size_t> allocate() noexcept
+        {
+            std::pair<void*, std::size_t> p{nullptr, 0};
+            if (!data.empty())
+            {
+                p = data.top();
+                data.pop();
+
+                ++allocated;
+            }
+            return p;
+        }
+
+        void deallocate(void* p, std::size_t n) noexcept
+        {
+            data.emplace(p, n);
+            if (++deallocated > 2 * (allocated + 16))
+            {
+                clear_cache();
+
+                allocated = 0;
+                deallocated = 0;
+            }
+        }
+
+        [[nodiscard]] bool empty() const noexcept
+        {
+            return data.empty();
+        }
+
+    private:
+        std::stack<std::pair<void*, std::size_t>> data;
+        std::size_t allocated = 0;
+        std::size_t deallocated = 0;
+        std::function<void()> clear_cache;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    allocated_cache& cache()
+    {
+        thread_local allocated_cache allocated_data;
+        return allocated_data;
+    }
+
+    void init_allocator_cache(std::function<void()>&& clear_cache)
+    {
+        cache().init(HPX_MOVE(clear_cache));
+    }
+
+    std::pair<void*, std::size_t> allocate_from_cache() noexcept
+    {
+        return cache().allocate();
+    }
+
+    void return_to_cache(void* p, std::size_t const n) noexcept
+    {
+        cache().deallocate(p, n);
+    }
+
+    bool cache_empty() noexcept
+    {
+        return cache().empty();
+    }
+}    // namespace hpx::util::detail
+
+#endif
diff --git a/libs/core/async_base/CMakeLists.txt b/libs/core/async_base/CMakeLists.txt
index 6a18a9e12b7..d8decefdf3d 100644
--- a/libs/core/async_base/CMakeLists.txt
+++ b/libs/core/async_base/CMakeLists.txt
@@ -34,6 +34,6 @@ add_hpx_module(
   COMPAT_HEADERS ${async_base_compat_headers}
   SOURCES ${async_base_sources}
   MODULE_DEPENDENCIES hpx_allocator_support hpx_concepts hpx_config
-                      hpx_concurrency hpx_coroutines hpx_tag_invoke
+                      hpx_coroutines hpx_tag_invoke
   CMAKE_SUBDIRS examples tests
 )
diff --git a/libs/core/async_base/include/hpx/async_base/dataflow.hpp b/libs/core/async_base/include/hpx/async_base/dataflow.hpp
index a6a3bb790bd..473657db88f 100644
--- a/libs/core/async_base/include/hpx/async_base/dataflow.hpp
+++ b/libs/core/async_base/include/hpx/async_base/dataflow.hpp
@@ -29,7 +29,6 @@ namespace hpx {
 #else
 
 #include <hpx/config.hpp>
-#include <hpx/concurrency/stack.hpp>
 #include <hpx/modules/allocator_support.hpp>
 #include <hpx/modules/concepts.hpp>
 #include <hpx/modules/tag_invoke.hpp>
@@ -61,14 +60,12 @@ namespace hpx {
             // clang-format on
             friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
                 dataflow_t tag, F&& f, Ts&&... ts)
-                -> decltype(tag(hpx::util::thread_local_caching_allocator<
-                                    hpx::lockfree::variable_size_stack, char,
+                -> decltype(tag(hpx::util::thread_local_caching_allocator<char,
                                     hpx::util::internal_allocator<>>{},
                     HPX_FORWARD(F, f), HPX_FORWARD(Ts, ts)...))
             {
                 using allocator_type =
-                    hpx::util::thread_local_caching_allocator<
-                        hpx::lockfree::variable_size_stack, char,
+                    hpx::util::thread_local_caching_allocator<char,
                         hpx::util::internal_allocator<>>;
                 return hpx::functional::tag_invoke(tag, allocator_type{},
                     HPX_FORWARD(F, f), HPX_FORWARD(Ts, ts)...);
diff --git a/libs/core/async_combinators/CMakeLists.txt b/libs/core/async_combinators/CMakeLists.txt
index ff730d928fe..df2809e7b38 100644
--- a/libs/core/async_combinators/CMakeLists.txt
+++ b/libs/core/async_combinators/CMakeLists.txt
@@ -43,7 +43,6 @@ add_hpx_module(
   EXCLUDE_FROM_GLOBAL_HEADER "hpx/async_combinators/future_wait.hpp"
   MODULE_DEPENDENCIES
     hpx_async_base
-    hpx_concurrency
     hpx_config
     hpx_errors
     hpx_futures
diff --git a/libs/core/async_combinators/include/hpx/async_combinators/when_all.hpp b/libs/core/async_combinators/include/hpx/async_combinators/when_all.hpp
index 3f4d400e5ee..8fff887a627 100644
--- a/libs/core/async_combinators/include/hpx/async_combinators/when_all.hpp
+++ b/libs/core/async_combinators/include/hpx/async_combinators/when_all.hpp
@@ -131,7 +131,6 @@ namespace hpx {
 #include <hpx/config.hpp>
 #include <hpx/allocator_support/internal_allocator.hpp>
 #include <hpx/allocator_support/thread_local_caching_allocator.hpp>
-#include <hpx/concurrency/stack.hpp>
 #include <hpx/datastructures/tuple.hpp>
 #include <hpx/functional/tag_invoke.hpp>
 #include <hpx/futures/detail/future_data.hpp>
@@ -229,8 +228,7 @@ namespace hpx::lcos::detail {
         using frame_type = async_when_all_frame<result_type>;
         using no_addref = typename frame_type::base_type::init_no_addref;
 
-        using allocator_type = hpx::util::thread_local_caching_allocator<
-            hpx::lockfree::variable_size_stack, char,
+        using allocator_type = hpx::util::thread_local_caching_allocator<char,
             hpx::util::internal_allocator<>>;
         auto frame = hpx::util::traverse_pack_async_allocator(allocator_type{},
             hpx::util::async_traverse_in_place_tag<frame_type>{}, no_addref{},
diff --git a/libs/core/execution/CMakeLists.txt b/libs/core/execution/CMakeLists.txt
index 0f36cbc4399..fc646a4c2b4 100644
--- a/libs/core/execution/CMakeLists.txt
+++ b/libs/core/execution/CMakeLists.txt
@@ -160,7 +160,6 @@ add_hpx_module(
   MODULE_DEPENDENCIES
     hpx_async_base
     hpx_async_combinators
-    hpx_concurrency
     hpx_config
     hpx_threading
     hpx_pack_traversal
diff --git a/libs/core/execution/include/hpx/execution/detail/future_exec.hpp b/libs/core/execution/include/hpx/execution/detail/future_exec.hpp
index a8d644afe1c..b45b81de529 100644
--- a/libs/core/execution/include/hpx/execution/detail/future_exec.hpp
+++ b/libs/core/execution/include/hpx/execution/detail/future_exec.hpp
@@ -13,7 +13,6 @@
 #include <hpx/assert.hpp>
 #include <hpx/async_base/launch_policy.hpp>
 #include <hpx/async_base/traits/is_launch_policy.hpp>
-#include <hpx/concurrency/stack.hpp>
 #include <hpx/coroutines/thread_enums.hpp>
 #include <hpx/execution/traits/executor_traits.hpp>
 #include <hpx/execution/traits/future_then_result_exec.hpp>
@@ -65,9 +64,9 @@ namespace hpx::lcos::detail {
             using continuation_result_type =
                 hpx::util::invoke_result_t<F, Future>;
 
-            using allocator_type = hpx::util::thread_local_caching_allocator<
-                hpx::lockfree::variable_size_stack, char,
-                hpx::util::internal_allocator<>>;
+            using allocator_type =
+                hpx::util::thread_local_caching_allocator<char,
+                    hpx::util::internal_allocator<>>;
 
             hpx::traits::detail::shared_state_ptr_t<result_type> p =
                 detail::make_continuation_alloc<continuation_result_type>(
diff --git a/libs/core/executors/CMakeLists.txt b/libs/core/executors/CMakeLists.txt
index 43985414eae..86123f574ef 100644
--- a/libs/core/executors/CMakeLists.txt
+++ b/libs/core/executors/CMakeLists.txt
@@ -97,7 +97,6 @@ add_hpx_module(
     hpx_allocator_support
     hpx_async_base
     hpx_concepts
-    hpx_concurrency
     hpx_config
     hpx_errors
     hpx_execution
diff --git a/libs/core/executors/include/hpx/executors/parallel_executor.hpp b/libs/core/executors/include/hpx/executors/parallel_executor.hpp
index 915551b7c57..15cfc6b67ae 100644
--- a/libs/core/executors/include/hpx/executors/parallel_executor.hpp
+++ b/libs/core/executors/include/hpx/executors/parallel_executor.hpp
@@ -12,7 +12,6 @@
 #include <hpx/allocator_support/internal_allocator.hpp>
 #include <hpx/allocator_support/thread_local_caching_allocator.hpp>
 #include <hpx/async_base/launch_policy.hpp>
-#include <hpx/concurrency/stack.hpp>
 #include <hpx/execution/detail/async_launch_policy_dispatch.hpp>
 #include <hpx/execution/detail/future_exec.hpp>
 #include <hpx/execution/detail/post_policy_dispatch.hpp>
@@ -390,9 +389,9 @@ namespace hpx::execution {
                 hpx::bind_back(HPX_FORWARD(F, f), HPX_FORWARD(Ts, ts)...));
 #endif
 
-            using allocator_type = hpx::util::thread_local_caching_allocator<
-                hpx::lockfree::variable_size_stack, char,
-                hpx::util::internal_allocator<>>;
+            using allocator_type =
+                hpx::util::thread_local_caching_allocator<char,
+                    hpx::util::internal_allocator<>>;
             hpx::traits::detail::shared_state_ptr_t<result_type> p =
                 lcos::detail::make_continuation_alloc_nounwrap<result_type>(
                     allocator_type{}, HPX_FORWARD(Future, predecessor),
diff --git a/libs/core/futures/CMakeLists.txt b/libs/core/futures/CMakeLists.txt
index bf0bd5c6821..7365dc74bdd 100644
--- a/libs/core/futures/CMakeLists.txt
+++ b/libs/core/futures/CMakeLists.txt
@@ -68,7 +68,6 @@ add_hpx_module(
     hpx_assertion
     hpx_async_base
     hpx_concepts
-    hpx_concurrency
     hpx_config
     hpx_errors
     hpx_functional
diff --git a/libs/core/futures/include/hpx/futures/future.hpp b/libs/core/futures/include/hpx/futures/future.hpp
index 7d83b551b36..b00109779d1 100644
--- a/libs/core/futures/include/hpx/futures/future.hpp
+++ b/libs/core/futures/include/hpx/futures/future.hpp
@@ -379,14 +379,13 @@ namespace hpx::lcos::detail {
         template <typename F>
         static auto then(Derived&& fut, F&& f, error_code& ec = throws)
             -> decltype(future_then_dispatch<std::decay_t<F>>::call_alloc(
-                hpx::util::thread_local_caching_allocator<
-                    hpx::lockfree::variable_size_stack, char,
+                hpx::util::thread_local_caching_allocator<char,
                     hpx::util::internal_allocator<>>{},
                 HPX_MOVE(fut), HPX_FORWARD(F, f)))
         {
-            using allocator_type = hpx::util::thread_local_caching_allocator<
-                hpx::lockfree::variable_size_stack, char,
-                hpx::util::internal_allocator<>>;
+            using allocator_type =
+                hpx::util::thread_local_caching_allocator<char,
+                    hpx::util::internal_allocator<>>;
 
             using result_type =
                 decltype(future_then_dispatch<std::decay_t<F>>::call_alloc(
@@ -406,14 +405,13 @@ namespace hpx::lcos::detail {
         template <typename F, typename T0>
         static auto then(Derived&& fut, T0&& t0, F&& f, error_code& ec = throws)
             -> decltype(future_then_dispatch<std::decay_t<T0>>::call_alloc(
-                hpx::util::thread_local_caching_allocator<
-                    hpx::lockfree::variable_size_stack, char,
+                hpx::util::thread_local_caching_allocator<char,
                     hpx::util::internal_allocator<>>{},
                 HPX_MOVE(fut), HPX_FORWARD(T0, t0), HPX_FORWARD(F, f)))
         {
-            using allocator_type = hpx::util::thread_local_caching_allocator<
-                hpx::lockfree::variable_size_stack, char,
-                hpx::util::internal_allocator<>>;
+            using allocator_type =
+                hpx::util::thread_local_caching_allocator<char,
+                    hpx::util::internal_allocator<>>;
 
             using result_type =
                 decltype(future_then_dispatch<std::decay_t<T0>>::call_alloc(
@@ -1249,8 +1247,7 @@ namespace hpx {
         std::is_constructible_v<T, Ts&&...> || std::is_void_v<T>, future<T>>
     make_ready_future(Ts&&... ts)
     {
-        using allocator_type = hpx::util::thread_local_caching_allocator<
-            hpx::lockfree::variable_size_stack, char,
+        using allocator_type = hpx::util::thread_local_caching_allocator<char,
             hpx::util::internal_allocator<>>;
         return make_ready_future_alloc<T>(
             allocator_type{}, HPX_FORWARD(Ts, ts)...);
@@ -1274,8 +1271,7 @@ namespace hpx {
     HPX_FORCEINLINE future<hpx::util::decay_unwrap_t<T>> make_ready_future(
         T&& init)
     {
-        using allocator_type = hpx::util::thread_local_caching_allocator<
-            hpx::lockfree::variable_size_stack, char,
+        using allocator_type = hpx::util::thread_local_caching_allocator<char,
             hpx::util::internal_allocator<>>;
         return hpx::make_ready_future_alloc<hpx::util::decay_unwrap_t<T>>(
             allocator_type{}, HPX_FORWARD(T, init));
@@ -1356,8 +1352,7 @@ namespace hpx {
     // extension: create a pre-initialized future object
     HPX_FORCEINLINE future<void> make_ready_future()
     {
-        using allocator_type = hpx::util::thread_local_caching_allocator<
-            hpx::lockfree::variable_size_stack, char,
+        using allocator_type = hpx::util::thread_local_caching_allocator<char,
             hpx::util::internal_allocator<>>;
         return make_ready_future_alloc<void>(allocator_type{}, util::unused);
     }
@@ -1599,8 +1594,7 @@ namespace hpx::lcos {
     std::enable_if_t<std::is_constructible_v<T, Ts&&...> || std::is_void_v<T>,
         hpx::future<T>> make_ready_future(Ts&&... ts)
     {
-        using allocator_type = hpx::util::thread_local_caching_allocator<
-            hpx::lockfree::variable_size_stack, char,
+        using allocator_type = hpx::util::thread_local_caching_allocator<char,
             hpx::util::internal_allocator<>>;
         return hpx::make_ready_future_alloc<T>(
             allocator_type{}, HPX_FORWARD(Ts, ts)...);
@@ -1623,8 +1617,7 @@ namespace hpx::lcos {
         "hpx::make_ready_future instead.")
     hpx::future<hpx::util::decay_unwrap_t<T>> make_ready_future(T&& init)
     {
-        using allocator_type = hpx::util::thread_local_caching_allocator<
-            hpx::lockfree::variable_size_stack, char,
+        using allocator_type = hpx::util::thread_local_caching_allocator<char,
             hpx::util::internal_allocator<>>;
         return hpx::make_ready_future_alloc<hpx::util::decay_unwrap_t<T>>(
             allocator_type{}, HPX_FORWARD(T, init));
@@ -1683,8 +1676,7 @@ namespace hpx::lcos {
         "hpx::make_ready_future instead.")
     inline hpx::future<void> make_ready_future()
     {
-        using allocator_type = hpx::util::thread_local_caching_allocator<
-            hpx::lockfree::variable_size_stack, char,
+        using allocator_type = hpx::util::thread_local_caching_allocator<char,
             hpx::util::internal_allocator<>>;
         return hpx::make_ready_future_alloc<void>(
             allocator_type{}, util::unused);
diff --git a/libs/core/futures/include/hpx/futures/futures_factory.hpp b/libs/core/futures/include/hpx/futures/futures_factory.hpp
index 3898333e56e..ac412045a4e 100644
--- a/libs/core/futures/include/hpx/futures/futures_factory.hpp
+++ b/libs/core/futures/include/hpx/futures/futures_factory.hpp
@@ -12,7 +12,6 @@
 #include <hpx/allocator_support/allocator_deleter.hpp>
 #include <hpx/allocator_support/internal_allocator.hpp>
 #include <hpx/async_base/launch_policy.hpp>
-#include <hpx/concurrency/stack.hpp>
 #include <hpx/coroutines/thread_enums.hpp>
 #include <hpx/errors/try_catch_exception_ptr.hpp>
 #include <hpx/execution_base/execution.hpp>
@@ -771,8 +770,7 @@ namespace hpx::lcos::local {
                 !std::is_same_v<std::decay_t<F>, futures_factory>>>
         explicit futures_factory(F&& f)
           : task_(detail::create_task_object<Result, Cancelable>::call(
-                hpx::util::thread_local_caching_allocator<
-                    hpx::lockfree::variable_size_stack, char,
+                hpx::util::thread_local_caching_allocator<char,
                     hpx::util::internal_allocator<>>{},
                 HPX_FORWARD(F, f)))
         {
@@ -780,8 +778,7 @@ namespace hpx::lcos::local {
 
         explicit futures_factory(Result (*f)())
           : task_(detail::create_task_object<Result, Cancelable>::call(
-                hpx::util::thread_local_caching_allocator<
-                    hpx::lockfree::variable_size_stack, char,
+                hpx::util::thread_local_caching_allocator<char,
                     hpx::util::internal_allocator<>>{},
                 f))
         {
diff --git a/libs/core/futures/include/hpx/futures/packaged_continuation.hpp b/libs/core/futures/include/hpx/futures/packaged_continuation.hpp
index 204f52bd10e..a7af9ea93e2 100644
--- a/libs/core/futures/include/hpx/futures/packaged_continuation.hpp
+++ b/libs/core/futures/include/hpx/futures/packaged_continuation.hpp
@@ -13,7 +13,6 @@
 #include <hpx/allocator_support/thread_local_caching_allocator.hpp>
 #include <hpx/assert.hpp>
 #include <hpx/async_base/launch_policy.hpp>
-#include <hpx/concurrency/stack.hpp>
 #include <hpx/errors/try_catch_exception_ptr.hpp>
 #include <hpx/futures/detail/future_data.hpp>
 #include <hpx/futures/traits/acquire_shared_state.hpp>
@@ -584,8 +583,7 @@ namespace hpx::lcos::detail {
     traits::detail::shared_state_ptr_t<future_unwrap_result_t<Future>> unwrap(
         Future&& future, error_code& ec)
     {
-        using allocator_type = hpx::util::thread_local_caching_allocator<
-            hpx::lockfree::variable_size_stack, char,
+        using allocator_type = hpx::util::thread_local_caching_allocator<char,
             hpx::util::internal_allocator<>>;
         return unwrap_impl_alloc(
             allocator_type{}, HPX_FORWARD(Future, future), ec);
diff --git a/libs/core/lcos_local/CMakeLists.txt b/libs/core/lcos_local/CMakeLists.txt
index b590593d9a3..2a4cec8e42e 100644
--- a/libs/core/lcos_local/CMakeLists.txt
+++ b/libs/core/lcos_local/CMakeLists.txt
@@ -48,7 +48,6 @@ add_hpx_module(
   HEADERS ${lcos_local_headers}
   COMPAT_HEADERS ${lcos_local_compat_headers}
   MODULE_DEPENDENCIES
-    hpx_concurrency
     hpx_config
     hpx_execution
     hpx_executors
diff --git a/libs/core/lcos_local/include/hpx/lcos_local/and_gate.hpp b/libs/core/lcos_local/include/hpx/lcos_local/and_gate.hpp
index 1961bc91614..bf5134ae1a8 100644
--- a/libs/core/lcos_local/include/hpx/lcos_local/and_gate.hpp
+++ b/libs/core/lcos_local/include/hpx/lcos_local/and_gate.hpp
@@ -10,7 +10,6 @@
 #include <hpx/allocator_support/internal_allocator.hpp>
 #include <hpx/allocator_support/thread_local_caching_allocator.hpp>
 #include <hpx/assert.hpp>
-#include <hpx/concurrency/stack.hpp>
 #include <hpx/datastructures/detail/dynamic_bitset.hpp>
 #include <hpx/datastructures/detail/intrusive_list.hpp>
 #include <hpx/functional/bind_front.hpp>
@@ -52,8 +51,7 @@ namespace hpx::lcos::local {
         explicit base_and_gate(std::size_t count = 0)
           : received_segments_(count)
           , promise_(std::allocator_arg,
-                hpx::util::thread_local_caching_allocator<
-                    hpx::lockfree::variable_size_stack, char,
+                hpx::util::thread_local_caching_allocator<char,
                     hpx::util::internal_allocator<>>{})
           , generation_(1)
         {
@@ -211,8 +209,7 @@ namespace hpx::lcos::local {
                 {
                     // we have received the last missing segment
                     using allocator_type =
-                        hpx::util::thread_local_caching_allocator<
-                            hpx::lockfree::variable_size_stack, char,
+                        hpx::util::thread_local_caching_allocator<char,
                             hpx::util::internal_allocator<>>;
 
                     hpx::promise<void> p(std::allocator_arg, allocator_type{});
diff --git a/libs/full/async_distributed/include/hpx/async_distributed/detail/async_implementations.hpp b/libs/full/async_distributed/include/hpx/async_distributed/detail/async_implementations.hpp
index d1fe5b1edce..004914058b6 100644
--- a/libs/full/async_distributed/include/hpx/async_distributed/detail/async_implementations.hpp
+++ b/libs/full/async_distributed/include/hpx/async_distributed/detail/async_implementations.hpp
@@ -17,7 +17,6 @@
 #include <hpx/components_base/pinned_ptr.hpp>
 #include <hpx/components_base/traits/action_decorate_function.hpp>
 #include <hpx/components_base/traits/component_supports_migration.hpp>
-#include <hpx/concurrency/stack.hpp>
 #include <hpx/functional/traits/get_function_address.hpp>
 #include <hpx/functional/traits/get_function_annotation.hpp>
 #include <hpx/futures/future.hpp>
@@ -205,8 +204,7 @@ namespace hpx::detail {
                 handle_managed_target<Result> hmt(id, f);
 
                 using allocator_type =
-                    hpx::util::thread_local_caching_allocator<
-                        hpx::lockfree::variable_size_stack, char,
+                    hpx::util::thread_local_caching_allocator<char,
                         hpx::util::internal_allocator<>>;
                 lcos::packaged_action<Action, Result> p(
                     std::allocator_arg, allocator_type{});
@@ -234,9 +232,9 @@ namespace hpx::detail {
         {
             handle_managed_target<result_type> hmt(id, f);
 
-            using allocator_type = hpx::util::thread_local_caching_allocator<
-                hpx::lockfree::variable_size_stack, char,
-                hpx::util::internal_allocator<>>;
+            using allocator_type =
+                hpx::util::thread_local_caching_allocator<char,
+                    hpx::util::internal_allocator<>>;
             lcos::packaged_action<action_type, result_type> p(
                 std::allocator_arg, allocator_type{});
 
@@ -260,9 +258,9 @@ namespace hpx::detail {
         {
             handle_managed_target<result_type> hmt(id, f);
 
-            using allocator_type = hpx::util::thread_local_caching_allocator<
-                hpx::lockfree::variable_size_stack, char,
-                hpx::util::internal_allocator<>>;
+            using allocator_type =
+                hpx::util::thread_local_caching_allocator<char,
+                    hpx::util::internal_allocator<>>;
             lcos::packaged_action<action_type, result_type> p(
                 std::allocator_arg, allocator_type{});
 
@@ -286,9 +284,9 @@ namespace hpx::detail {
         {
             handle_managed_target<result_type> hmt(id, f);
 
-            using allocator_type = hpx::util::thread_local_caching_allocator<
-                hpx::lockfree::variable_size_stack, char,
-                hpx::util::internal_allocator<>>;
+            using allocator_type =
+                hpx::util::thread_local_caching_allocator<char,
+                    hpx::util::internal_allocator<>>;
             lcos::packaged_action<action_type, result_type> p(
                 std::allocator_arg, allocator_type{});
 
@@ -550,8 +548,7 @@ namespace hpx::detail {
             if (policy == launch::sync || hpx::detail::has_async_policy(policy))
             {
                 using allocator_type =
-                    hpx::util::thread_local_caching_allocator<
-                        hpx::lockfree::variable_size_stack, char,
+                    hpx::util::thread_local_caching_allocator<char,
                         hpx::util::internal_allocator<>>;
                 lcos::packaged_action<action_type, result_type> p(
                     std::allocator_arg, allocator_type{});
@@ -565,8 +562,7 @@ namespace hpx::detail {
             else if (policy == launch::deferred)
             {
                 using allocator_type =
-                    hpx::util::thread_local_caching_allocator<
-                        hpx::lockfree::variable_size_stack, char,
+                    hpx::util::thread_local_caching_allocator<char,
                         hpx::util::internal_allocator<>>;
                 lcos::packaged_action<action_type, result_type> p(
                     std::allocator_arg, allocator_type{});
@@ -634,9 +630,9 @@ namespace hpx::detail {
         {
             handle_managed_target<result_type> hmt(id, f);
 
-            using allocator_type = hpx::util::thread_local_caching_allocator<
-                hpx::lockfree::variable_size_stack, char,
-                hpx::util::internal_allocator<>>;
+            using allocator_type =
+                hpx::util::thread_local_caching_allocator<char,
+                    hpx::util::internal_allocator<>>;
             lcos::packaged_action<action_type, result_type> p(
                 std::allocator_arg, allocator_type{});
 
@@ -714,9 +710,9 @@ namespace hpx::detail {
         {
             handle_managed_target<result_type> hmt(id, f);
 
-            using allocator_type = hpx::util::thread_local_caching_allocator<
-                hpx::lockfree::variable_size_stack, char,
-                hpx::util::internal_allocator<>>;
+            using allocator_type =
+                hpx::util::thread_local_caching_allocator<char,
+                    hpx::util::internal_allocator<>>;
             lcos::packaged_action<action_type, result_type> p(
                 std::allocator_arg, allocator_type{});
 
@@ -743,9 +739,9 @@ namespace hpx::detail {
         {
             handle_managed_target<result_type> hmt(id, f);
 
-            using allocator_type = hpx::util::thread_local_caching_allocator<
-                hpx::lockfree::variable_size_stack, char,
-                hpx::util::internal_allocator<>>;
+            using allocator_type =
+                hpx::util::thread_local_caching_allocator<char,
+                    hpx::util::internal_allocator<>>;
             lcos::packaged_action<action_type, result_type> p(
                 std::allocator_arg, allocator_type{});