diff --git a/src/agrpc/detail/allocate_operation.hpp b/src/agrpc/detail/allocate_operation.hpp
index b21858f9..e4741ba0 100644
--- a/src/agrpc/detail/allocate_operation.hpp
+++ b/src/agrpc/detail/allocate_operation.hpp
@@ -35,53 +35,31 @@ template <class T>
 inline constexpr bool IS_STD_ALLOCATOR<std::allocator<T>> = true;
 
 template <template <class> class OperationTemplate, class Handler, class... Args>
-auto allocate_custom_operation(Handler&& handler, Args&&... args)
-{
-    const auto allocator = detail::get_allocator(handler);
-    auto operation = detail::allocate<OperationTemplate<detail::RemoveCrefT<Handler>>>(
-        allocator, detail::AllocationType::CUSTOM, static_cast<Handler&&>(handler), static_cast<Args&&>(args)...);
-    return operation.release();
-}
-
-template <template <class> class OperationTemplate, class Handler, class... Args>
-auto allocate_local_operation(agrpc::GrpcContext& grpc_context, Handler&& handler, Args&&... args)
+auto allocate_operation(Handler&& handler, Args&&... args)
 {
     using DecayedHandler = detail::RemoveCrefT<Handler>;
-    auto allocator = detail::get_allocator(handler);
-    if constexpr (detail::IS_STD_ALLOCATOR<decltype(allocator)>)
+    using Op = OperationTemplate<DecayedHandler>;
+    using Allocator = detail::AssociatedAllocatorT<DecayedHandler>;
+    if constexpr (detail::IS_STD_ALLOCATOR<Allocator>)
     {
-        auto operation = detail::allocate<OperationTemplate<DecayedHandler>>(
-            grpc_context.get_allocator(), detail::AllocationType::LOCAL, static_cast<Handler&&>(handler),
-            static_cast<Args&&>(args)...);
+        if (GrpcContextImplementation::running_in_this_thread())
+        {
+            auto operation = detail::allocate<Op>(PoolResourceAllocator<Op>{}, detail::AllocationType::LOCAL,
+                                                  static_cast<Handler&&>(handler), static_cast<Args&&>(args)...);
+            return operation.release();
+        }
+        auto operation = detail::allocate<Op>(std::allocator<Op>{}, detail::AllocationType::CUSTOM,
+                                              static_cast<Handler&&>(handler), static_cast<Args&&>(args)...);
         return operation.release();
     }
     else
     {
-        auto operation = detail::allocate<OperationTemplate<DecayedHandler>>(
-            allocator, detail::AllocationType::CUSTOM, static_cast<Handler&&>(handler), static_cast<Args&&>(args)...);
+        const auto allocator = detail::get_allocator(handler);
+        auto operation = detail::allocate<Op>(allocator, detail::AllocationType::CUSTOM,
+                                              static_cast<Handler&&>(handler), static_cast<Args&&>(args)...);
         return operation.release();
     }
 }
-
-template <template <class> class OperationTemplate, class Handler, class... Args>
-auto allocate_operation(bool, agrpc::GrpcContext&, Handler&& handler, Args&&... args)
-{
-    // if (is_running_in_this_thread)
-    // {
-    //     return detail::allocate_local_operation<OperationTemplate>(grpc_context, static_cast<Handler&&>(handler),
-    //                                                                static_cast<Args&&>(args)...);
-    // }
-    return detail::allocate_custom_operation<OperationTemplate>(static_cast<Handler&&>(handler),
-                                                                static_cast<Args&&>(args)...);
-}
-
-template <template <class> class OperationTemplate, class Handler, class... Args>
-auto allocate_operation(agrpc::GrpcContext& grpc_context, Handler&& handler, Args&&... args)
-{
-    return detail::allocate_operation<OperationTemplate>(
-        detail::GrpcContextImplementation::running_in_this_thread(grpc_context), grpc_context,
-        static_cast<Handler&&>(handler), static_cast<Args&&>(args)...);
-}
 }
 
 AGRPC_NAMESPACE_END
diff --git a/src/agrpc/detail/atomic_intrusive_queue.hpp b/src/agrpc/detail/atomic_intrusive_queue.hpp
index bf79cca8..8b0f7eda 100644
--- a/src/agrpc/detail/atomic_intrusive_queue.hpp
+++ b/src/agrpc/detail/atomic_intrusive_queue.hpp
@@ -97,11 +97,6 @@ class AtomicIntrusiveQueue
         return detail::IntrusiveQueue<Item>::make_reversed(static_cast<Item*>(old_value));
     }
 
-    [[nodiscard]] bool is_inactive() const noexcept
-    {
-        return head_.load(std::memory_order_relaxed) == producer_inactive_value();
-    }
-
   private:
     [[nodiscard]] void* producer_inactive_value() const noexcept
     {
diff --git a/src/agrpc/detail/basic_sender.hpp b/src/agrpc/detail/basic_sender.hpp
index ec7a29d2..2313e97d 100644
--- a/src/agrpc/detail/basic_sender.hpp
+++ b/src/agrpc/detail/basic_sender.hpp
@@ -199,7 +199,7 @@ class BasicSenderRunningOperation : public detail::BaseForSenderImplementationTy
     }
 
     template <AllocationType, class... Args>
-    void complete(const agrpc::GrpcContext&, Args... args) noexcept
+    void complete(Args... args) noexcept
     {
         reset_stop_callback();
         exec::set_value(static_cast<Receiver&&>(receiver()), static_cast<Args&&>(args)...);
diff --git a/src/agrpc/detail/create_and_submit_no_arg_operation.hpp b/src/agrpc/detail/create_and_submit_no_arg_operation.hpp
index c3cfe48e..6a285fff 100644
--- a/src/agrpc/detail/create_and_submit_no_arg_operation.hpp
+++ b/src/agrpc/detail/create_and_submit_no_arg_operation.hpp
@@ -44,15 +44,13 @@ void create_and_submit_no_arg_operation(agrpc::GrpcContext& grpc_context, Handle
         }
     }
     detail::StartWorkAndGuard guard{grpc_context};
+    auto operation = detail::allocate_operation<detail::NoArgOperation>(static_cast<Handler&&>(handler));
     if (is_running_in_this_thread)
     {
-        auto operation =
-            detail::allocate_local_operation<detail::NoArgOperation>(grpc_context, static_cast<Handler&&>(handler));
         detail::GrpcContextImplementation::add_local_operation(operation);
     }
     else
     {
-        auto operation = detail::allocate_custom_operation<detail::NoArgOperation>(static_cast<Handler&&>(handler));
         detail::GrpcContextImplementation::add_remote_operation(grpc_context, operation);
     }
     guard.release();
diff --git a/src/agrpc/detail/grpc_context.ipp b/src/agrpc/detail/grpc_context.ipp
index 2f7cd939..4db14e74 100644
--- a/src/agrpc/detail/grpc_context.ipp
+++ b/src/agrpc/detail/grpc_context.ipp
@@ -41,7 +41,6 @@ struct AlwaysFalsePredicate
 inline void drain_completion_queue(agrpc::GrpcContext& grpc_context)
 {
     detail::GrpcContextThreadContext thread_context{grpc_context};
-    detail::ThreadLocalGrpcContextGuard guard{thread_context};
     while (detail::GrpcContextImplementation::do_one(thread_context, detail::GrpcContextImplementation::INFINITE_FUTURE,
                                                      detail::InvokeHandler::NO_, detail::AlwaysFalsePredicate{}))
     {
@@ -53,17 +52,45 @@ inline grpc::CompletionQueue* get_completion_queue(agrpc::GrpcContext& grpc_cont
 {
     return grpc_context.get_completion_queue();
 }
+
+template <class T>
+inline void create_resources(T& resources, std::size_t thread_count_hint = 1)
+{
+    for (size_t i{}; i != thread_count_hint; ++i)
+    {
+        auto resource = new detail::StackablePoolResource();
+        resources.push_front(*resource);
+    }
+}
+
+template <class T>
+inline void delete_resources(T& resources)
+{
+    while (!resources.empty())
+    {
+        delete &resources.pop_front();
+    }
+}
 }  // namespace detail
 
+inline GrpcContext::GrpcContext() { detail::create_resources(resources_); }
+
+inline GrpcContext::GrpcContext(std::size_t thread_count_hint) : multithreaded_{thread_count_hint > 1}
+{
+    detail::create_resources(resources_, thread_count_hint);
+}
+
 template <class>
 inline GrpcContext::GrpcContext(std::unique_ptr<grpc::CompletionQueue>&& completion_queue)
     : completion_queue_(static_cast<std::unique_ptr<grpc::CompletionQueue>&&>(completion_queue))
 {
+    detail::create_resources(resources_);
 }
 
 inline GrpcContext::GrpcContext(std::unique_ptr<grpc::ServerCompletionQueue> completion_queue)
     : completion_queue_(static_cast<std::unique_ptr<grpc::ServerCompletionQueue>&&>(completion_queue))
 {
+    detail::create_resources(resources_);
 }
 
 inline GrpcContext::~GrpcContext()
@@ -76,6 +103,7 @@ inline GrpcContext::~GrpcContext()
     asio::execution_context::shutdown();
     asio::execution_context::destroy();
 #endif
+    detail::delete_resources(resources_);
 }
 
 inline bool GrpcContext::run()
@@ -161,7 +189,7 @@ inline GrpcContext::executor_type GrpcContext::get_executor() noexcept { return
 
 inline GrpcContext::executor_type GrpcContext::get_scheduler() noexcept { return GrpcContext::executor_type{*this}; }
 
-inline GrpcContext::allocator_type GrpcContext::get_allocator() noexcept { return allocator_type{&local_resource_}; }
+inline GrpcContext::allocator_type GrpcContext::get_allocator() noexcept { return allocator_type{}; }
 
 inline void GrpcContext::work_started() noexcept { outstanding_work_.fetch_add(1, std::memory_order_relaxed); }
 
diff --git a/src/agrpc/detail/grpc_context_implementation.hpp b/src/agrpc/detail/grpc_context_implementation.hpp
index f117bd34..7ce41ad8 100644
--- a/src/agrpc/detail/grpc_context_implementation.hpp
+++ b/src/agrpc/detail/grpc_context_implementation.hpp
@@ -20,6 +20,8 @@
 #include <agrpc/detail/grpc_completion_queue_event.hpp>
 #include <agrpc/detail/intrusive_queue.hpp>
 #include <agrpc/detail/operation_base.hpp>
+#include <agrpc/detail/pool_resource.hpp>
+#include <agrpc/detail/stackable_pool_resource.hpp>
 #include <agrpc/detail/utility.hpp>
 #include <grpcpp/completion_queue.h>
 
@@ -58,40 +60,31 @@ struct StartWorkAndGuard : detail::WorkFinishedOnExit
     StartWorkAndGuard& operator=(StartWorkAndGuard&&) = delete;
 };
 
-struct GrpcLocalContext
+struct GrpcContextThreadContext
+#if defined(AGRPC_STANDALONE_ASIO) || defined(AGRPC_BOOST_ASIO)
+    // Enables Boost.Asio's awaitable frame memory recycling
+    : asio::detail::thread_context
+#endif
 {
-    explicit GrpcLocalContext(agrpc::GrpcContext& grpc_context);
+    explicit GrpcContextThreadContext(agrpc::GrpcContext& grpc_context);
+
+    ~GrpcContextThreadContext() noexcept;
+
+    GrpcContextThreadContext(const GrpcContextThreadContext& other) = delete;
+    GrpcContextThreadContext(GrpcContextThreadContext&& other) = delete;
+    GrpcContextThreadContext& operator=(const GrpcContextThreadContext& other) = delete;
+    GrpcContextThreadContext& operator=(GrpcContextThreadContext&& other) = delete;
 
     agrpc::GrpcContext& grpc_context_;
     detail::IntrusiveQueue<detail::QueueableOperationBase> local_work_queue_;
     bool check_remote_work_;
-};
+    GrpcContextThreadContext* old_context_;
+    detail::StackablePoolResource& resource_;
 
 #if defined(AGRPC_STANDALONE_ASIO) || defined(AGRPC_BOOST_ASIO)
-// Enables Boost.Asio's awaitable frame memory recycling
-struct GrpcContextThreadContext : GrpcLocalContext, asio::detail::thread_context
-{
-    using GrpcLocalContext::GrpcLocalContext;
-
     asio::detail::thread_info_base this_thread_;
     thread_call_stack::context ctx_{this, this_thread_};
-};
-#else
-using GrpcContextThreadContext = GrpcLocalContext;
 #endif
-
-struct ThreadLocalGrpcContextGuard
-{
-    detail::GrpcContextThreadContext* old_context_;
-
-    explicit ThreadLocalGrpcContextGuard(detail::GrpcContextThreadContext& context) noexcept;
-
-    ~ThreadLocalGrpcContextGuard();
-
-    ThreadLocalGrpcContextGuard(const ThreadLocalGrpcContextGuard&) = delete;
-    ThreadLocalGrpcContextGuard(ThreadLocalGrpcContextGuard&&) = delete;
-    ThreadLocalGrpcContextGuard& operator=(const ThreadLocalGrpcContextGuard&) = delete;
-    ThreadLocalGrpcContextGuard& operator=(ThreadLocalGrpcContextGuard&&) = delete;
 };
 
 struct IsGrpcContextStoppedPredicate
@@ -126,6 +119,8 @@ struct GrpcContextImplementation
     static bool handle_next_completion_queue_event(detail::GrpcContextThreadContext& context, ::gpr_timespec deadline,
                                                    detail::InvokeHandler invoke);
 
+    [[nodiscard]] static bool running_in_this_thread() noexcept;
+
     [[nodiscard]] static bool running_in_this_thread(const agrpc::GrpcContext& grpc_context) noexcept;
 
     static bool move_local_queue_to_remote_work(detail::GrpcContextThreadContext& context) noexcept;
@@ -147,6 +142,10 @@ struct GrpcContextImplementation
 
     template <class LoopFunction>
     static bool process_work(agrpc::GrpcContext& grpc_context, LoopFunction loop_function);
+
+    static detail::StackablePoolResource& pop_resource(agrpc::GrpcContext& grpc_context);
+
+    static void push_resource(agrpc::GrpcContext& grpc_context, detail::StackablePoolResource& resource);
 };
 
 void process_grpc_tag(void* tag, detail::OperationResult result, agrpc::GrpcContext& grpc_context);
diff --git a/src/agrpc/detail/grpc_context_implementation.ipp b/src/agrpc/detail/grpc_context_implementation.ipp
index 580fd7e3..33c831b2 100644
--- a/src/agrpc/detail/grpc_context_implementation.ipp
+++ b/src/agrpc/detail/grpc_context_implementation.ipp
@@ -24,34 +24,44 @@
 #include <grpc/support/time.h>
 #include <grpcpp/completion_queue.h>
 
+#include <agrpc/detail/config.hpp>
+
 AGRPC_NAMESPACE_BEGIN()
 
 namespace detail
 {
 inline thread_local detail::GrpcContextThreadContext* thread_local_grpc_context{};
 
-inline GrpcLocalContext::GrpcLocalContext(agrpc::GrpcContext& grpc_context)
-    : grpc_context_(grpc_context), check_remote_work_{false}
-{
-}
-
-inline ThreadLocalGrpcContextGuard::ThreadLocalGrpcContextGuard(detail::GrpcContextThreadContext& context) noexcept
-    : old_context_{std::exchange(detail::thread_local_grpc_context, &context)}
+inline GrpcContextThreadContext::GrpcContextThreadContext(agrpc::GrpcContext& grpc_context)
+    : grpc_context_(grpc_context),
+      local_work_queue_{grpc_context.multithreaded_ ? agrpc::GrpcContext::LocalWorkQueue{}
+                                                    : std::move(grpc_context.local_work_queue_)},
+      check_remote_work_{grpc_context.multithreaded_ ? false : grpc_context.check_remote_work_},
+      old_context_{std::exchange(detail::thread_local_grpc_context, this)},
+      resource_{old_context_ ? old_context_->resource_ : GrpcContextImplementation::pop_resource(grpc_context)}
 {
 }
 
-inline ThreadLocalGrpcContextGuard::~ThreadLocalGrpcContextGuard()
+inline GrpcContextThreadContext::~GrpcContextThreadContext() noexcept
 {
-    auto* const context = detail::thread_local_grpc_context;
-    bool check_remote_work = context->check_remote_work_;
-    while (check_remote_work)
+    if (grpc_context_.multithreaded_)
     {
-        check_remote_work = GrpcContextImplementation::move_remote_work_to_local_queue(*context);
+        bool check_remote_work = check_remote_work_;
+        while (check_remote_work)
+        {
+            check_remote_work = GrpcContextImplementation::move_remote_work_to_local_queue(*this);
+        }
+        if (GrpcContextImplementation::move_local_queue_to_remote_work(*this))
+        {
+            GrpcContextImplementation::trigger_work_alarm(grpc_context_);
+        }
     }
-    if (GrpcContextImplementation::move_local_queue_to_remote_work(*context))
+    else
     {
-        GrpcContextImplementation::trigger_work_alarm(context->grpc_context_);
+        grpc_context_.local_work_queue_ = std::move(local_work_queue_);
+        grpc_context_.check_remote_work_ = check_remote_work_;
     }
+    GrpcContextImplementation::push_resource(grpc_context_, resource_);
     detail::thread_local_grpc_context = old_context_;
 }
 
@@ -111,9 +121,12 @@ inline void GrpcContextImplementation::add_operation(agrpc::GrpcContext& grpc_co
     }
 }
 
+inline bool GrpcContextImplementation::running_in_this_thread() noexcept { return detail::thread_local_grpc_context; }
+
 inline bool GrpcContextImplementation::running_in_this_thread(const agrpc::GrpcContext& grpc_context) noexcept
 {
-    return detail::thread_local_grpc_context && &grpc_context == &detail::thread_local_grpc_context->grpc_context_;
+    auto* const context = detail::thread_local_grpc_context;
+    return context && &grpc_context == &context->grpc_context_;
 }
 
 inline bool GrpcContextImplementation::move_local_queue_to_remote_work(
@@ -266,7 +279,6 @@ inline bool GrpcContextImplementation::process_work(agrpc::GrpcContext& grpc_con
     }
     grpc_context.reset();
     detail::GrpcContextThreadContext thread_context{grpc_context};
-    detail::ThreadLocalGrpcContextGuard guard{thread_context};
     bool processed{};
     while (loop_function(thread_context))
     {
@@ -275,6 +287,24 @@ inline bool GrpcContextImplementation::process_work(agrpc::GrpcContext& grpc_con
     return processed;
 }
 
+inline detail::StackablePoolResource& GrpcContextImplementation::pop_resource(agrpc::GrpcContext& grpc_context)
+{
+    std::lock_guard guard{grpc_context.resources_mutex_};
+    auto& resources = grpc_context.resources_;
+    if (resources.empty())
+    {
+        return *(new detail::StackablePoolResource());
+    }
+    return resources.pop_front();
+}
+
+inline void GrpcContextImplementation::push_resource(agrpc::GrpcContext& grpc_context,
+                                                     detail::StackablePoolResource& resource)
+{
+    std::lock_guard guard{grpc_context.resources_mutex_};
+    grpc_context.resources_.push_front(resource);
+}
+
 inline void process_grpc_tag(void* tag, detail::OperationResult result, agrpc::GrpcContext& grpc_context)
 {
     detail::WorkFinishedOnExit on_exit{grpc_context};
@@ -289,9 +319,50 @@ inline ::gpr_timespec gpr_timespec_from_now(std::chrono::nanoseconds duration) n
     return ::gpr_time_add(timespec, duration_timespec);
 }
 
-inline detail::GrpcContextLocalAllocator get_local_allocator(agrpc::GrpcContext& grpc_context) noexcept
+inline detail::GrpcContextLocalAllocator get_local_allocator() noexcept { return detail::GrpcContextLocalAllocator(); }
+
+inline detail::PoolResource& get_local_pool_resource() noexcept
 {
-    return grpc_context.get_allocator();
+    return detail::thread_local_grpc_context->resource_.resource_;
+}
+
+template <class T>
+inline T* PoolResourceAllocator<T>::allocate(std::size_t n)
+{
+    if constexpr (alignof(T) > MAX_ALIGN)
+    {
+        return std::allocator<T>{}.allocate(n);
+    }
+    else
+    {
+        const auto allocation_size = n * sizeof(T);
+        if (allocation_size > LARGEST_POOL_BLOCK_SIZE)
+        {
+            return std::allocator<T>{}.allocate(n);
+        }
+        return static_cast<T*>(detail::get_local_pool_resource().allocate(allocation_size));
+    }
+}
+
+template <class T>
+inline void PoolResourceAllocator<T>::deallocate(T* p, std::size_t n) noexcept
+{
+    if constexpr (alignof(T) > MAX_ALIGN)
+    {
+        return std::allocator<T>{}.deallocate(p);
+    }
+    else
+    {
+        const auto allocation_size = n * sizeof(T);
+        if (allocation_size > LARGEST_POOL_BLOCK_SIZE)
+        {
+            std::allocator<T>{}.deallocate(p, n);
+        }
+        else
+        {
+            detail::get_local_pool_resource().deallocate(p, allocation_size);
+        }
+    }
 }
 }
 
diff --git a/src/agrpc/detail/grpc_context_local_allocator.hpp b/src/agrpc/detail/grpc_context_local_allocator.hpp
index 8ff44a6b..89f3129f 100644
--- a/src/agrpc/detail/grpc_context_local_allocator.hpp
+++ b/src/agrpc/detail/grpc_context_local_allocator.hpp
@@ -15,22 +15,17 @@
 #ifndef AGRPC_DETAIL_GRPC_CONTEXT_HPP
 #define AGRPC_DETAIL_GRPC_CONTEXT_HPP
 
-#include <agrpc/detail/forward.hpp>
-#include <agrpc/detail/pool_resource.hpp>
 #include <agrpc/detail/pool_resource_allocator.hpp>
 
-#include <cstddef>
-
 #include <agrpc/detail/config.hpp>
 
 AGRPC_NAMESPACE_BEGIN()
 
 namespace detail
 {
-using GrpcContextLocalMemoryResource = detail::PoolResource;
 using GrpcContextLocalAllocator = detail::PoolResourceAllocator<std::byte>;
 
-detail::GrpcContextLocalAllocator get_local_allocator(agrpc::GrpcContext& grpc_context) noexcept;
+detail::GrpcContextLocalAllocator get_local_allocator() noexcept;
 }
 
 AGRPC_NAMESPACE_END
diff --git a/src/agrpc/detail/health_check_service.hpp b/src/agrpc/detail/health_check_service.hpp
index 9f78059d..337e57a5 100644
--- a/src/agrpc/detail/health_check_service.hpp
+++ b/src/agrpc/detail/health_check_service.hpp
@@ -85,8 +85,7 @@ class HealthCheckWatcher : public detail::IntrusiveListHook<detail::HealthCheckW
 
     static auto create_and_initiate(agrpc::HealthCheckService& service, void* tag)
     {
-        auto& grpc_context = *service.grpc_context_;
-        return Base::create(grpc_context, service, tag);
+        return Base::create(service, tag);
     }
 
   private:
@@ -148,17 +147,14 @@ class HealthCheckChecker : public detail::OperationBase
 
     static auto create_and_initiate(agrpc::HealthCheckService& service, void* tag)
     {
-        auto& grpc_context = *service.grpc_context_;
-        return detail::allocate<HealthCheckChecker>(grpc_context.get_allocator(), service, tag).release();
+        return detail::allocate<HealthCheckChecker>(detail::get_local_allocator(), service, tag).release();
     }
 
-    void deallocate() { detail::destroy_deallocate(this, get_allocator()); }
+    void deallocate() { detail::destroy_deallocate(this, detail::get_local_allocator()); }
 
   private:
     agrpc::GrpcContext& grpc_context() const noexcept { return *service_.grpc_context_; }
 
-    agrpc::GrpcContext::allocator_type get_allocator() const noexcept { return grpc_context().get_allocator(); }
-
     static void do_complete(Base* op, detail::OperationResult, agrpc::GrpcContext& grpc_context)
     {
         auto* self = static_cast<HealthCheckChecker*>(op);
diff --git a/src/agrpc/detail/intrusive_stack.hpp b/src/agrpc/detail/intrusive_stack.hpp
new file mode 100644
index 00000000..c20e0a1d
--- /dev/null
+++ b/src/agrpc/detail/intrusive_stack.hpp
@@ -0,0 +1,60 @@
+// Copyright 2024 Dennis Hezel
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef AGRPC_DETAIL_INTRUSIVE_STACK_HPP
+#define AGRPC_DETAIL_INTRUSIVE_STACK_HPP
+
+#include <utility>
+
+#include <agrpc/detail/config.hpp>
+
+AGRPC_NAMESPACE_BEGIN()
+
+namespace detail
+{
+template <class T>
+class IntrusiveStack
+{
+  public:
+    IntrusiveStack() : head_(nullptr) {}
+
+    IntrusiveStack(IntrusiveStack&& other) noexcept : head_(std::exchange(other.head_, nullptr)) {}
+
+    IntrusiveStack(const IntrusiveStack&) = delete;
+    IntrusiveStack& operator=(const IntrusiveStack&) = delete;
+    IntrusiveStack& operator=(IntrusiveStack&&) = delete;
+
+    [[nodiscard]] bool empty() const noexcept { return head_ == nullptr; }
+
+    void push_front(T& item) noexcept
+    {
+        item.next_ = head_;
+        head_ = &item;
+    }
+
+    [[nodiscard]] T& pop_front() noexcept
+    {
+        T* item = head_;
+        head_ = item->next_;
+        return *item;
+    }
+
+  private:
+    T* head_;
+};
+}
+
+AGRPC_NAMESPACE_END
+
+#endif  // AGRPC_DETAIL_INTRUSIVE_STACK_HPP
diff --git a/src/agrpc/detail/operation.hpp b/src/agrpc/detail/operation.hpp
index 5f8a70e2..2fdc3843 100644
--- a/src/agrpc/detail/operation.hpp
+++ b/src/agrpc/detail/operation.hpp
@@ -34,14 +34,14 @@ class NoArgOperation : public detail::QueueableOperationBase
     using Base = detail::QueueableOperationBase;
 
     template <bool UseLocalAllocator>
-    static void do_complete(detail::OperationBase* op, OperationResult result, agrpc::GrpcContext& grpc_context)
+    static void do_complete(detail::OperationBase* op, OperationResult result, agrpc::GrpcContext&)
     {
         auto* self = static_cast<NoArgOperation*>(op);
         detail::AllocationGuard ptr{self, [&]
                                     {
                                         if constexpr (UseLocalAllocator)
                                         {
-                                            return detail::get_local_allocator(grpc_context);
+                                            return detail::get_local_allocator();
                                         }
                                         else
                                         {
diff --git a/src/agrpc/detail/operation_base.hpp b/src/agrpc/detail/operation_base.hpp
index b11fb4ba..00c461e4 100644
--- a/src/agrpc/detail/operation_base.hpp
+++ b/src/agrpc/detail/operation_base.hpp
@@ -15,7 +15,6 @@
 #ifndef AGRPC_DETAIL_OPERATION_BASE_HPP
 #define AGRPC_DETAIL_OPERATION_BASE_HPP
 
-#include <agrpc/detail/allocate.hpp>
 #include <agrpc/detail/forward.hpp>
 #include <agrpc/detail/utility.hpp>
 
diff --git a/src/agrpc/detail/operation_handle.hpp b/src/agrpc/detail/operation_handle.hpp
index e05fe0d4..9b3f41f0 100644
--- a/src/agrpc/detail/operation_handle.hpp
+++ b/src/agrpc/detail/operation_handle.hpp
@@ -36,7 +36,7 @@ struct BasicOperationHandle
         template <class... Args>
         void operator()(Args&&... args)
         {
-            self_.template complete<AllocType>(grpc_context_, static_cast<Args&&>(args)...);
+            self_.template complete<AllocType>(static_cast<Args&&>(args)...);
         }
 
         void done() { self_.done(); }
diff --git a/src/agrpc/detail/operation_implementation.hpp b/src/agrpc/detail/operation_implementation.hpp
index 628ae610..0c5410c0 100644
--- a/src/agrpc/detail/operation_implementation.hpp
+++ b/src/agrpc/detail/operation_implementation.hpp
@@ -42,7 +42,7 @@ void complete(Operation& operation, [[maybe_unused]] detail::OperationResult res
         else
         {
             operation.implementation().complete(grpc_context, args...);
-            operation.template complete<AllocType>(grpc_context, static_cast<decltype(args)&&>(args)...);
+            operation.template complete<AllocType>(static_cast<decltype(args)&&>(args)...);
         }
     };
     if constexpr (Implementation::TYPE == detail::SenderImplementationType::BOTH ||
diff --git a/src/agrpc/detail/pool_resource.hpp b/src/agrpc/detail/pool_resource.hpp
index 8ff55ec9..79aabbb3 100644
--- a/src/agrpc/detail/pool_resource.hpp
+++ b/src/agrpc/detail/pool_resource.hpp
@@ -15,8 +15,6 @@
 #ifndef AGRPC_DETAIL_POOL_RESOURCE_HPP
 #define AGRPC_DETAIL_POOL_RESOURCE_HPP
 
-#include <agrpc/detail/intrusive_circular_list.hpp>
-#include <agrpc/detail/intrusive_slist.hpp>
 #include <agrpc/detail/math.hpp>
 #include <agrpc/detail/memory.hpp>
 
@@ -24,183 +22,79 @@
 
 #include <agrpc/detail/config.hpp>
 
-// The following PoolResource and related functions have been adapted from
-// https://github.com/boostorg/container/blob/develop/src/pool_resource.cpp
-
 AGRPC_NAMESPACE_BEGIN()
 
 namespace detail
 {
-class MemoryBlockList
-{
-  private:
-    struct Header : detail::IntrusiveCircularListHook
-    {
-        std::size_t size_;
-    };
-
-    using List = detail::IntrusiveCircularList;
-
-    static constexpr std::size_t HEADER_SIZE = detail::align(sizeof(Header), MAX_ALIGN);
-
-  public:
-    void* allocate(std::size_t size)
-    {
-        const auto allocation_size = size + HEADER_SIZE;
-        void* p = MaxAlignAllocator::allocate(allocation_size);
-        auto* const header = ::new (p) Header;
-        header->size_ = allocation_size;
-        list_.push_front(header);
-        return static_cast<char*>(p) + HEADER_SIZE;
-    }
-
-    static void deallocate(void* p)
-    {
-        auto* header = reinterpret_cast<Header*>(static_cast<char*>(p) - HEADER_SIZE);
-        List::remove(header);
-        const auto size = header->size_;
-        header->~Header();
-        MaxAlignAllocator::deallocate(header, size);
-    }
-
-    void release() noexcept
-    {
-        for (auto it = list_.begin(); it != list_.end();)
-        {
-            auto& header = static_cast<Header&>(*it);
-            ++it;
-            std::size_t size = header.size_;
-            header.~Header();
-            MaxAlignAllocator::deallocate(&header, size);
-        }
-        list_.clear();
-    }
-
-  private:
-    List list_;
-};
-
-class MemoryBlockSlist
+class Pool
 {
   private:
-    struct Header
-    {
-        Header* next_;
-        std::size_t size_;
-    };
-
-    using List = detail::IntrusiveSlist<Header>;
-
-    static constexpr std::size_t HEADER_SIZE = detail::align(sizeof(Header), MAX_ALIGN);
+    static constexpr std::size_t BLOCK_COUNT = 4;
 
   public:
-    void* allocate_already_max_aligned(std::size_t size)
+    void* allocate_block(std::size_t pool_size)
     {
-        const auto allocation_size = size + HEADER_SIZE;
-        void* p = MaxAlignAllocator::allocate_already_max_aligned(allocation_size);
-        auto* const header = ::new (p) Header;
-        header->size_ = allocation_size;
-        slist_.push_front(header);
-        return static_cast<char*>(p) + HEADER_SIZE;
-    }
-
-    void release_already_max_aligned() noexcept
-    {
-        for (auto it = slist_.begin(); it != slist_.end();)
+        for (auto& block : blocks)
         {
-            auto& header = *it;
-            ++it;
-            const auto size = header.size_;
-            header.~Header();
-            MaxAlignAllocator::deallocate_already_max_aligned(&header, size);
+            if (block)
+            {
+                return std::exchange(block, nullptr);
+            }
         }
-        slist_.clear();
+        return MaxAlignAllocator::allocate_already_max_aligned(pool_size);
     }
 
-  private:
-    List slist_;
-};
-
-class Pool
-{
-  private:
-    struct FreeListEntry
-    {
-        FreeListEntry* next_;
-    };
-
-    using FreeList = detail::IntrusiveSlist<FreeListEntry>;
-
-    static constexpr std::size_t MINIMUM_MAX_BLOCKS_PER_CHUNK = 1u;
-    static constexpr std::size_t MAX_BLOCKS_PER_CHUNK = 32u;
-
-  public:
-    void* allocate_block() noexcept
+    void deallocate_block(void* p, std::size_t pool_size) noexcept
     {
-        if (free_slist_.empty())
+        for (auto& block : blocks)
         {
-            return nullptr;
+            if (!block)
+            {
+                block = p;
+                return;
+            }
         }
-        auto* pv = free_slist_.pop_front();
-        pv->~FreeListEntry();
-        return pv;
-    }
-
-    void deallocate_block(void* p) noexcept
-    {
-        auto* pv = ::new (p) FreeListEntry;
-        free_slist_.push_front(pv);
-    }
-
-    void release() noexcept
-    {
-        free_slist_.clear();
-        block_slist_.release_already_max_aligned();
-        next_blocks_per_chunk_ = MINIMUM_MAX_BLOCKS_PER_CHUNK;
+        MaxAlignAllocator::deallocate_already_max_aligned(p, pool_size);
     }
 
-    void replenish(std::size_t block_size)
+    void release(std::size_t pool_size) noexcept
     {
-        const std::size_t blocks_per_chunk = next_blocks_per_chunk_;
-
-        // Minimum block size is at least max_align, so all pools allocate sizes that are multiple of max_align,
-        // meaning that all blocks are max_align-aligned.
-        auto* p = static_cast<char*>(block_slist_.allocate_already_max_aligned(blocks_per_chunk * block_size));
-
-        for (std::size_t i{}; i != blocks_per_chunk; ++i)
+        for (auto& block : blocks)
         {
-            auto* const pv = ::new (static_cast<void*>(p)) FreeListEntry;
-            free_slist_.push_front(pv);
-            p += block_size;
+            if (block)
+            {
+                MaxAlignAllocator::deallocate_already_max_aligned(block, pool_size);
+            }
         }
-
-        next_blocks_per_chunk_ =
-            MAX_BLOCKS_PER_CHUNK / 2u < blocks_per_chunk ? MAX_BLOCKS_PER_CHUNK : blocks_per_chunk * 2u;
     }
 
   private:
-    MemoryBlockSlist block_slist_;
-    FreeList free_slist_;
-    std::size_t next_blocks_per_chunk_{MINIMUM_MAX_BLOCKS_PER_CHUNK};
+    void* blocks[BLOCK_COUNT]{};
 };
 
-inline constexpr std::size_t POWER_OF_TWO_SIZEOF_VOID_PTR = (sizeof(void*) % 2 == 0) ? sizeof(void*) : MAX_ALIGN;
-inline constexpr std::size_t SMALLEST_POOL_BLOCK_SIZE =
-    MAX_ALIGN > 2 * POWER_OF_TWO_SIZEOF_VOID_PTR ? MAX_ALIGN : 2 * POWER_OF_TWO_SIZEOF_VOID_PTR;
+inline constexpr std::size_t SMALLEST_POOL_BLOCK_SIZE = 32u;
 inline constexpr std::size_t SMALLEST_POOL_BLOCK_SIZE_LOG2 = detail::ceil_log2(SMALLEST_POOL_BLOCK_SIZE);
-inline constexpr std::size_t LARGEST_POOL_BLOCK_SIZE =
-    SMALLEST_POOL_BLOCK_SIZE > 4096u ? SMALLEST_POOL_BLOCK_SIZE : 4096u;
+inline constexpr std::size_t LARGEST_POOL_BLOCK_SIZE = 512u;
 
-constexpr std::size_t get_pool_index(std::size_t block_size) noexcept
+constexpr std::size_t get_pool_index(std::size_t size) noexcept
 {
     // For allocations equal or less than SMALLEST_POOL_BLOCK_SIZE the smallest pool is used
-    block_size = detail::maximum(block_size, SMALLEST_POOL_BLOCK_SIZE);
-    return detail::ceil_log2(block_size) - SMALLEST_POOL_BLOCK_SIZE_LOG2;
+    size = detail::maximum(size, SMALLEST_POOL_BLOCK_SIZE);
+    return detail::ceil_log2(size) - SMALLEST_POOL_BLOCK_SIZE_LOG2;
 }
 
-constexpr std::size_t get_block_size_of_pool_at(std::size_t index) noexcept
+constexpr std::size_t get_pool_size(std::size_t pool_idx) noexcept { return SMALLEST_POOL_BLOCK_SIZE << pool_idx; }
+
+struct PoolIndexAndSize
+{
+    std::size_t index;
+    std::size_t size;
+};
+
+constexpr PoolIndexAndSize get_pool_index_and_size(std::size_t size) noexcept
 {
-    return SMALLEST_POOL_BLOCK_SIZE << index;
+    const auto pool_idx = detail::get_pool_index(size);
+    return {pool_idx, detail::get_pool_size(pool_idx)};
 }
 
 class PoolResource
@@ -208,54 +102,37 @@ class PoolResource
   public:
     PoolResource() = default;
 
-    ~PoolResource() noexcept { release(); }
+    ~PoolResource() noexcept
+    {
+        auto pool_size = SMALLEST_POOL_BLOCK_SIZE;
+        for (auto& pool : pools_)
+        {
+            pool.release(pool_size);
+            pool_size <<= 1;
+        }
+    }
 
     PoolResource(const PoolResource& other) = delete;
     PoolResource(PoolResource&& other) = delete;
     PoolResource& operator=(const PoolResource& other) = delete;
     PoolResource& operator=(PoolResource&& other) = delete;
 
-    [[nodiscard]] void* allocate(std::size_t bytes, std::size_t /*alignment ignored, max_align is used by pools*/)
+    [[nodiscard]] void* allocate(std::size_t size)
     {
-        if (bytes > LARGEST_POOL_BLOCK_SIZE)
-        {
-            return oversized_list_.allocate(bytes);
-        }
-        const auto pool_idx = detail::get_pool_index(bytes);
-        Pool& pool = pools_[pool_idx];
-        void* p = pool.allocate_block();
-        if (p == nullptr)
-        {
-            pool.replenish(detail::get_block_size_of_pool_at(pool_idx));
-            p = pool.allocate_block();
-        }
-        return p;
+        const auto [pool_idx, pool_size] = detail::get_pool_index_and_size(size);
+        return pools_[pool_idx].allocate_block(pool_size);
     }
 
-    void deallocate(void* p, std::size_t bytes, std::size_t /*alignment ignored, max_align is used by pools*/)
+    void deallocate(void* p, std::size_t size)
     {
-        if (bytes > LARGEST_POOL_BLOCK_SIZE)
-        {
-            return MemoryBlockList::deallocate(p);
-        }
-        const auto pool_idx = detail::get_pool_index(bytes);
-        return pools_[pool_idx].deallocate_block(p);
-    }
-
-    void release() noexcept
-    {
-        oversized_list_.release();
-        for (auto& pool : pools_)
-        {
-            pool.release();
-        }
+        const auto [pool_idx, pool_size] = detail::get_pool_index_and_size(size);
+        pools_[pool_idx].deallocate_block(p, pool_size);
     }
 
   private:
     static constexpr std::size_t POOL_COUNT = detail::get_pool_index(LARGEST_POOL_BLOCK_SIZE) + 1u;
 
-    MemoryBlockList oversized_list_;
-    Pool pools_[POOL_COUNT];
+    Pool pools_[POOL_COUNT]{};
 };
 }
 
diff --git a/src/agrpc/detail/pool_resource_allocator.hpp b/src/agrpc/detail/pool_resource_allocator.hpp
index 01fc4570..635c1943 100644
--- a/src/agrpc/detail/pool_resource_allocator.hpp
+++ b/src/agrpc/detail/pool_resource_allocator.hpp
@@ -15,8 +15,6 @@
 #ifndef AGRPC_DETAIL_POOL_RESOURCE_ALLOCATOR_HPP
 #define AGRPC_DETAIL_POOL_RESOURCE_ALLOCATOR_HPP
 
-#include <agrpc/detail/pool_resource.hpp>
-
 #include <cstddef>
 
 #include <agrpc/detail/config.hpp>
@@ -33,44 +31,32 @@ class PoolResourceAllocator
 
     PoolResourceAllocator() = default;
 
-    explicit PoolResourceAllocator(PoolResource* resource) noexcept : resource_(resource) {}
-
     PoolResourceAllocator(const PoolResourceAllocator&) = default;
 
     template <class U>
-    PoolResourceAllocator(const detail::PoolResourceAllocator<U>& other) noexcept : resource_(other.resource_)
+    PoolResourceAllocator(const detail::PoolResourceAllocator<U>&) noexcept
     {
     }
 
-    PoolResourceAllocator& operator=(const PoolResourceAllocator& other) = delete;
+    PoolResourceAllocator& operator=(const PoolResourceAllocator& other) = default;
 
-    PoolResourceAllocator& operator=(PoolResourceAllocator&& other) = delete;
+    PoolResourceAllocator& operator=(PoolResourceAllocator&& other) = default;
 
-    [[nodiscard]] T* allocate(std::size_t n)
-    {
-        static_assert(alignof(T) <= MAX_ALIGN, "Overaligned types are not supported");
-        return static_cast<T*>(resource_->allocate(n * sizeof(T), alignof(T)));
-    }
+    [[nodiscard]] static T* allocate(std::size_t n);
 
-    void deallocate(T* p, std::size_t n) noexcept { resource_->deallocate(p, n * sizeof(T), alignof(T)); }
+    static void deallocate(T* p, std::size_t n) noexcept;
 
     template <class U>
-    friend bool operator==(const PoolResourceAllocator& lhs, const detail::PoolResourceAllocator<U>& rhs) noexcept
+    friend bool operator==(const PoolResourceAllocator&, const detail::PoolResourceAllocator<U>&) noexcept
     {
-        return lhs.resource_ == rhs.resource_;
+        return true;
     }
 
     template <class U>
-    friend bool operator!=(const PoolResourceAllocator& lhs, const detail::PoolResourceAllocator<U>& rhs) noexcept
+    friend bool operator!=(const PoolResourceAllocator&, const detail::PoolResourceAllocator<U>&) noexcept
     {
-        return lhs.resource_ != rhs.resource_;
+        return false;
     }
-
-  private:
-    template <class>
-    friend class detail::PoolResourceAllocator;
-
-    PoolResource* resource_;
 };
 }
 
diff --git a/src/agrpc/detail/sender_implementation_operation.hpp b/src/agrpc/detail/sender_implementation_operation.hpp
index 12f785f5..2391b144 100644
--- a/src/agrpc/detail/sender_implementation_operation.hpp
+++ b/src/agrpc/detail/sender_implementation_operation.hpp
@@ -50,7 +50,7 @@ struct SenderImplementationOperation : public detail::BaseForSenderImplementatio
         }
         else
         {
-            [[maybe_unused]] detail::AllocationGuard ptr{self, self->template get_allocator<AllocType>(grpc_context)};
+            [[maybe_unused]] detail::AllocationGuard ptr{self, self->template get_allocator<AllocType>()};
         }
     }
 
@@ -77,11 +77,11 @@ struct SenderImplementationOperation : public detail::BaseForSenderImplementatio
     }
 
     template <AllocationType AllocType>
-    decltype(auto) get_allocator(agrpc::GrpcContext& grpc_context) noexcept
+    decltype(auto) get_allocator() noexcept
     {
         if constexpr (AllocType == detail::AllocationType::LOCAL)
         {
-            return grpc_context.get_allocator();
+            return detail::get_local_allocator();
         }
         else
         {
@@ -116,9 +116,9 @@ struct SenderImplementationOperation : public detail::BaseForSenderImplementatio
     }
 
     template <AllocationType AllocType, class... Args>
-    void complete(agrpc::GrpcContext& grpc_context, Args... args)
+    void complete(Args... args)
     {
-        detail::AllocationGuard ptr{this, get_allocator<AllocType>(grpc_context)};
+        detail::AllocationGuard ptr{this, get_allocator<AllocType>()};
         detail::dispatch_complete(ptr, static_cast<Args&&>(args)...);
     }
 
@@ -142,7 +142,7 @@ void submit_sender_implementation_operation(agrpc::GrpcContext& grpc_context, Co
     }
     detail::allocate_operation<
         detail::SenderImplementationOperationTemplate<detail::RemoveCrefT<Implementation>>::template Type>(
-        grpc_context, static_cast<CompletionHandler&&>(completion_handler), grpc_context, initiation,
+        static_cast<CompletionHandler&&>(completion_handler), grpc_context, initiation,
         static_cast<Implementation&&>(implementation));
 }
 }
diff --git a/src/agrpc/detail/server_write_reactor.hpp b/src/agrpc/detail/server_write_reactor.hpp
index ebffcb8b..57364411 100644
--- a/src/agrpc/detail/server_write_reactor.hpp
+++ b/src/agrpc/detail/server_write_reactor.hpp
@@ -56,9 +56,9 @@ class ServerWriteReactor : public detail::ServerWriteReactorStepBase, public det
     }
 
     template <class... Args>
-    static auto create(agrpc::GrpcContext& grpc_context, Args&&... args)
+    static auto create(Args&&... args)
     {
-        return detail::allocate<Derived>(grpc_context.get_allocator(), static_cast<Args&&>(args)...).release();
+        return detail::allocate<Derived>(detail::get_local_allocator(), static_cast<Args&&>(args)...).release();
     }
 
     [[nodiscard]] bool is_writing() const noexcept { return &ServerWriteReactor::do_write_done == get_on_complete(); }
@@ -83,7 +83,7 @@ class ServerWriteReactor : public detail::ServerWriteReactorStepBase, public det
     void deallocate() { detail::destroy_deallocate(static_cast<Derived*>(this), get_allocator()); }
 
   private:
-    auto get_allocator() const noexcept { return grpc_context_.get_allocator(); }
+    auto get_allocator() const noexcept { return detail::get_local_allocator(); }
 
     auto get_on_complete() const noexcept
     {
diff --git a/src/agrpc/detail/stackable_pool_resource.hpp b/src/agrpc/detail/stackable_pool_resource.hpp
new file mode 100644
index 00000000..0c13a94f
--- /dev/null
+++ b/src/agrpc/detail/stackable_pool_resource.hpp
@@ -0,0 +1,35 @@
+// Copyright 2024 Dennis Hezel
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef AGRPC_DETAIL_STACKABLE_POOL_RESOURCE_HPP
+#define AGRPC_DETAIL_STACKABLE_POOL_RESOURCE_HPP
+
+#include <agrpc/detail/pool_resource.hpp>
+
+#include <agrpc/detail/config.hpp>
+
+AGRPC_NAMESPACE_BEGIN()
+
+namespace detail
+{
+struct StackablePoolResource
+{
+    StackablePoolResource* next_;
+    detail::PoolResource resource_;
+};
+}
+
+AGRPC_NAMESPACE_END
+
+#endif  // AGRPC_DETAIL_STACKABLE_POOL_RESOURCE_HPP
diff --git a/src/agrpc/grpc_context.hpp b/src/agrpc/grpc_context.hpp
index 830925c1..2b6d7002 100644
--- a/src/agrpc/grpc_context.hpp
+++ b/src/agrpc/grpc_context.hpp
@@ -23,12 +23,15 @@
 #include <agrpc/detail/grpc_executor_options.hpp>
 #include <agrpc/detail/intrusive_list.hpp>
 #include <agrpc/detail/intrusive_queue.hpp>
+#include <agrpc/detail/intrusive_stack.hpp>
 #include <agrpc/detail/operation_base.hpp>
+#include <agrpc/detail/stackable_pool_resource.hpp>
 #include <grpcpp/alarm.h>
 #include <grpcpp/completion_queue.h>
 
 #include <atomic>
 #include <memory>
+#include <mutex>
 
 #include <agrpc/detail/config.hpp>
 
@@ -57,14 +60,16 @@ class GrpcContext
     /**
      * @brief The associated allocator type
      */
-    using allocator_type = detail::GrpcContextLocalAllocator;
+    using allocator_type = std::allocator<std::byte>;
 
     /**
      * @brief Construct a GrpcContext for gRPC clients
      *
      * @since 2.4.0
      */
-    GrpcContext() = default;
+    GrpcContext();
+
+    explicit GrpcContext(std::size_t thread_count_hint);
 
     template <class = void>
     [[deprecated("For gRPC clients use the default constructor")]] explicit GrpcContext(
@@ -288,10 +293,10 @@ class GrpcContext
   private:
     using RemoteWorkQueue = detail::AtomicIntrusiveQueue<detail::QueueableOperationBase>;
     using LocalWorkQueue = detail::IntrusiveQueue<detail::QueueableOperationBase>;
+    using Resources = detail::IntrusiveStack<detail::StackablePoolResource>;
 
     friend detail::GrpcContextImplementation;
-    friend detail::GrpcLocalContext;
-    friend detail::ThreadLocalGrpcContextGuard;
+    friend detail::GrpcContextThreadContext;
 
     bool run_until_impl(::gpr_timespec deadline);
 
@@ -299,9 +304,13 @@ class GrpcContext
     std::atomic_long outstanding_work_{};
     std::atomic_bool stopped_{false};
     std::atomic_bool shutdown_{false};
+    bool check_remote_work_{false};
+    bool multithreaded_{false};
+    LocalWorkQueue local_work_queue_{};
     std::unique_ptr<grpc::CompletionQueue> completion_queue_{std::make_unique<grpc::CompletionQueue>()};
-    detail::GrpcContextLocalMemoryResource local_resource_;
     RemoteWorkQueue remote_work_queue_{false};
+    std::mutex resources_mutex_;
+    Resources resources_;
 };
 
 AGRPC_NAMESPACE_END
diff --git a/src/agrpc/run.hpp b/src/agrpc/run.hpp
index b130dfa2..525dfe6c 100644
--- a/src/agrpc/run.hpp
+++ b/src/agrpc/run.hpp
@@ -250,7 +250,6 @@ void run_impl(agrpc::GrpcContext& grpc_context, ExecutionContext& execution_cont
     using Backoff =
         detail::Backoff<std::chrono::duration_cast<detail::BackoffDelay>(ResolvedTraits::MAX_LATENCY).count()>;
     detail::GrpcContextThreadContext thread_context{grpc_context};
-    detail::ThreadLocalGrpcContextGuard guard{thread_context};
     Backoff backoff;
     auto delay = backoff.next();
     IsGrpcContextStopped is_grpc_context_stopped{};
diff --git a/test/src/test_grpc_context_17.cpp b/test/src/test_grpc_context_17.cpp
index 67c9e2b0..30463590 100644
--- a/test/src/test_grpc_context_17.cpp
+++ b/test/src/test_grpc_context_17.cpp
@@ -547,21 +547,26 @@ inline void wait_some(agrpc::GrpcContext& grpc_context)
                                     });
 }
 
-inline void post_some(agrpc::GrpcContext& grpc_context)
+inline void post_some(agrpc::GrpcContext& grpc_context, asio::thread_pool& pool)
 {
-    asio::post(grpc_context,
+    asio::post(pool,
                [&]
                {
-                   post_some(grpc_context);
+                   asio::post(grpc_context,
+                              [&]
+                              {
+                                  post_some(grpc_context, pool);
+                              });
                });
 }
 
 TEST_CASE_FIXTURE(test::GrpcContextTest, "GrpcContext.run() parallel")
 {
-    asio::thread_pool pool{10};
+    grpc_context_lifetime.emplace(5);
     for (size_t j{}; j != 3; ++j)
     {
-        for (size_t i{}; i != 5; ++i)
+        asio::thread_pool pool{4};
+        for (size_t i{}; i != 2; ++i)
         {
             asio::post(pool,
                        [&]
@@ -569,11 +574,11 @@ TEST_CASE_FIXTURE(test::GrpcContextTest, "GrpcContext.run() parallel")
                            wait_some(grpc_context);
                        });
         }
-        for (size_t i{}; i != 5; ++i)
+        for (size_t i{}; i != 2; ++i)
         {
-            post_some(grpc_context);
+            post_some(grpc_context, pool);
         }
-        for (size_t i{}; i != 5; ++i)
+        for (size_t i{}; i != 2; ++i)
         {
             asio::post(pool,
                        [&]
@@ -581,7 +586,7 @@ TEST_CASE_FIXTURE(test::GrpcContextTest, "GrpcContext.run() parallel")
                            grpc_context.run();
                        });
         }
-        asio::steady_timer timer{pool, std::chrono::seconds(1)};
+        asio::steady_timer timer{pool, std::chrono::milliseconds(500)};
         timer.async_wait(
             [&](auto&&...)
             {