diff --git a/example/snippets/client_rpc.cpp b/example/snippets/client_rpc.cpp
index f781ea5f..c368f792 100644
--- a/example/snippets/client_rpc.cpp
+++ b/example/snippets/client_rpc.cpp
@@ -20,7 +20,7 @@
 namespace asio = boost::asio;
 
 /* [client_rpc-unary] */
-asio::awaitable<void> unary(agrpc::GrpcContext& grpc_context, example::v1::Example::Stub& stub)
+asio::awaitable<void> client_rpc_unary(agrpc::GrpcContext& grpc_context, example::v1::Example::Stub& stub)
 {
     using RPC = agrpc::ClientRPC<&example::v1::Example::Stub::PrepareAsyncUnary>;
     grpc::ClientContext client_context;
@@ -38,7 +38,7 @@ asio::awaitable<void> unary(agrpc::GrpcContext& grpc_context, example::v1::Examp
 /* [client_rpc-unary] */
 
 /* [client_rpc-client-streaming] */
-asio::awaitable<void> client_streaming(agrpc::GrpcContext& grpc_context, example::v1::Example::Stub& stub)
+asio::awaitable<void> client_rpc_client_streaming(agrpc::GrpcContext& grpc_context, example::v1::Example::Stub& stub)
 {
     using RPC = asio::use_awaitable_t<>::as_default_on_t<
         agrpc::ClientRPC<&example::v1::Example::Stub::PrepareAsyncClientStreaming>>;
@@ -74,7 +74,7 @@ asio::awaitable<void> client_streaming(agrpc::GrpcContext& grpc_context, example
 /* [client_rpc-client-streaming] */
 
 /* [client_rpc-server-streaming] */
-asio::awaitable<void> server_streaming(agrpc::GrpcContext& grpc_context, example::v1::Example::Stub& stub)
+asio::awaitable<void> client_rpc_server_streaming(agrpc::GrpcContext& grpc_context, example::v1::Example::Stub& stub)
 {
     using RPC = asio::use_awaitable_t<>::as_default_on_t<
         agrpc::ClientRPC<&example::v1::Example::Stub::PrepareAsyncServerStreaming>>;
@@ -107,7 +107,8 @@ asio::awaitable<void> server_streaming(agrpc::GrpcContext& grpc_context, example
 /* [client_rpc-server-streaming] */
 
 /* [client_rpc-bidi-streaming] */
-asio::awaitable<void> bidirectional_streaming(agrpc::GrpcContext& grpc_context, example::v1::Example::Stub& stub)
+asio::awaitable<void> client_rpc_bidirectional_streaming(agrpc::GrpcContext& grpc_context,
+                                                         example::v1::Example::Stub& stub)
 {
     using RPC = asio::use_awaitable_t<>::as_default_on_t<
         agrpc::ClientRPC<&example::v1::Example::Stub::PrepareAsyncBidirectionalStreaming>>;
@@ -143,7 +144,7 @@ asio::awaitable<void> bidirectional_streaming(agrpc::GrpcContext& grpc_context,
 /* [client_rpc-bidi-streaming] */
 
 /* [client_rpc-generic-unary] */
-asio::awaitable<void> generic_unary(agrpc::GrpcContext& grpc_context, grpc::GenericStub& stub)
+asio::awaitable<void> client_rpc_generic_unary(agrpc::GrpcContext& grpc_context, grpc::GenericStub& stub)
 {
     grpc::ClientContext client_context;
     client_context.set_deadline(std::chrono::system_clock::now() + std::chrono::seconds(5));
@@ -179,5 +180,5 @@ asio::awaitable<void> generic_unary(agrpc::GrpcContext& grpc_context, grpc::Gene
 /* [client_rpc-generic-unary] */
 
 /* [client_rpc-generic-streaming] */
-asio::awaitable<void> client_generic_streaming_request(grpc::GenericStub&) { co_return; }
+asio::awaitable<void> client_rpc_generic_streaming(agrpc::GrpcContext&, grpc::GenericStub&) { co_return; }
 /* [client_rpc-generic-streaming] */
diff --git a/src/agrpc/client_rpc.hpp b/src/agrpc/client_rpc.hpp
index 41eda736..fe4aa7ee 100644
--- a/src/agrpc/client_rpc.hpp
+++ b/src/agrpc/client_rpc.hpp
@@ -23,46 +23,12 @@
 #include <agrpc/detail/initiate_sender_implementation.hpp>
 #include <agrpc/detail/name.hpp>
 #include <agrpc/detail/rpc_client_context_base.hpp>
+#include <agrpc/detail/rpc_executor_base.hpp>
 #include <agrpc/detail/rpc_type.hpp>
 #include <agrpc/grpc_executor.hpp>
 
 AGRPC_NAMESPACE_BEGIN()
 
-namespace detail
-{
-/**
- * @brief (experimental) RPC's executor base
- *
- * @since 2.1.0
- */
-template <class Executor>
-class RPCExecutorBase
-{
-  public:
-    /**
-     * @brief The executor type
-     */
-    using executor_type = Executor;
-
-    /**
-     * @brief Get the executor
-     *
-     * Thread-safe
-     */
-    [[nodiscard]] const executor_type& get_executor() const noexcept { return executor_; }
-
-  protected:
-    RPCExecutorBase() : executor_(agrpc::GrpcExecutor{}) {}
-
-    explicit RPCExecutorBase(const Executor& executor) : executor_(executor) {}
-
-    auto& grpc_context() const noexcept { return detail::query_grpc_context(executor_); }
-
-  private:
-    Executor executor_;
-};
-}
-
 namespace detail
 {
 /**
@@ -521,7 +487,7 @@ class ClientRPC<PrepareAsyncClientStreaming, Executor>
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
     auto read_initial_metadata(CompletionToken token = detail::DefaultCompletionTokenT<Executor>{})
     {
-        return detail::async_initiate_sender_implementation<detail::ReadInitialMetadataSenderImplementation<ClientRPC>>(
+        return detail::async_initiate_sender_implementation<detail::ReadInitialMetadataSenderImplementation<Responder>>(
             this->grpc_context(), {}, {*this}, token);
     }
 
@@ -536,7 +502,7 @@ class ClientRPC<PrepareAsyncClientStreaming, Executor>
                CompletionToken token = detail::DefaultCompletionTokenT<Executor>{})
     {
         return detail::async_initiate_sender_implementation<
-            detail::WriteClientStreamingSenderImplementation<ClientRPC>>(this->grpc_context(), {request, options},
+            detail::WriteClientStreamingSenderImplementation<Responder>>(this->grpc_context(), {request, options},
                                                                          {*this}, token);
     }
 
@@ -591,8 +557,8 @@ class ClientRPC<PrepareAsyncClientStreaming, Executor>
     }
 
   private:
-    friend detail::ReadInitialMetadataSenderImplementation<ClientRPC>;
-    friend detail::WriteClientStreamingSenderImplementation<ClientRPC>;
+    friend detail::ReadInitialMetadataSenderImplementation<Responder>;
+    friend detail::WriteClientStreamingSenderImplementation<Responder>;
     friend detail::ClientFinishSenderImplementation<ClientRPC>;
     friend detail::ClientStreamingRequestSenderInitiation<PrepareAsyncClientStreaming, Executor>;
     friend detail::ClientStreamingRequestSenderImplementation<PrepareAsyncClientStreaming, Executor>;
@@ -766,9 +732,8 @@ class ClientRPCServerStreamingBase<PrepareAsyncServerStreaming, Executor>
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
     auto read_initial_metadata(CompletionToken token = detail::DefaultCompletionTokenT<Executor>{})
     {
-        return detail::async_initiate_sender_implementation<
-            detail::ReadInitialMetadataSenderImplementation<ClientRPCServerStreamingBase>>(this->grpc_context(), {},
-                                                                                           {*this}, token);
+        return detail::async_initiate_sender_implementation<detail::ReadInitialMetadataSenderImplementation<Responder>>(
+            this->grpc_context(), {}, {*this}, token);
     }
 
     /**
@@ -785,9 +750,8 @@ class ClientRPCServerStreamingBase<PrepareAsyncServerStreaming, Executor>
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
     auto read(ResponseT& response, CompletionToken token = detail::DefaultCompletionTokenT<Executor>{})
     {
-        return detail::async_initiate_sender_implementation<
-            detail::ReadServerStreamingSenderImplementation<ClientRPCServerStreamingBase>>(this->grpc_context(),
-                                                                                           {response}, {*this}, token);
+        return detail::async_initiate_sender_implementation<detail::ReadServerStreamingSenderImplementation<Responder>>(
+            this->grpc_context(), {response}, {*this}, token);
     }
 
     /**
@@ -822,14 +786,14 @@ class ClientRPCServerStreamingBase<PrepareAsyncServerStreaming, Executor>
     auto finish(CompletionToken token = detail::DefaultCompletionTokenT<Executor>{})
     {
         return detail::async_initiate_sender_implementation<
-            detail::ClientFinishServerStreamingSenderImplementation<ClientRPCServerStreamingBase>>(this->grpc_context(),
-                                                                                                   {}, {*this}, token);
+            detail::ClientFinishServerStreamingSenderImplementation<Responder>>(this->grpc_context(), {}, {*this},
+                                                                                token);
     }
 
   private:
-    friend detail::ReadInitialMetadataSenderImplementation<ClientRPCServerStreamingBase>;
-    friend detail::ReadServerStreamingSenderImplementation<ClientRPCServerStreamingBase>;
-    friend detail::ClientFinishServerStreamingSenderImplementation<ClientRPCServerStreamingBase>;
+    friend detail::ReadInitialMetadataSenderImplementation<Responder>;
+    friend detail::ReadServerStreamingSenderImplementation<Responder>;
+    friend detail::ClientFinishServerStreamingSenderImplementation<Responder>;
     friend detail::ClientStreamingRequestSenderInitiation<PrepareAsyncServerStreaming, Executor>;
     friend detail::ClientStreamingRequestSenderImplementation<PrepareAsyncServerStreaming, Executor>;
 };
@@ -969,9 +933,8 @@ class ClientRPCBidiStreamingBase<ResponderT<RequestT, ResponseT>, Executor>
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
     auto read_initial_metadata(CompletionToken token = detail::DefaultCompletionTokenT<Executor>{})
     {
-        return detail::async_initiate_sender_implementation<
-            detail::ReadInitialMetadataSenderImplementation<ClientRPCBidiStreamingBase>>(this->grpc_context(), {},
-                                                                                         {*this}, token);
+        return detail::async_initiate_sender_implementation<detail::ReadInitialMetadataSenderImplementation<Responder>>(
+            this->grpc_context(), {}, {*this}, token);
     }
 
     /**
@@ -990,8 +953,8 @@ class ClientRPCBidiStreamingBase<ResponderT<RequestT, ResponseT>, Executor>
     auto read(ResponseT& response, CompletionToken token = detail::DefaultCompletionTokenT<Executor>{})
     {
         return detail::async_initiate_sender_implementation<
-            detail::ClientReadBidiStreamingSenderImplementation<Responder, Executor>>(this->grpc_context(), {response},
-                                                                                      {*this}, token);
+            detail::ClientReadBidiStreamingSenderImplementation<Responder>>(this->grpc_context(), {response}, {*this},
+                                                                            token);
     }
 
     /**
@@ -1012,8 +975,8 @@ class ClientRPCBidiStreamingBase<ResponderT<RequestT, ResponseT>, Executor>
                CompletionToken token = detail::DefaultCompletionTokenT<Executor>{})
     {
         return detail::async_initiate_sender_implementation<
-            detail::ClientWriteBidiStreamingSenderImplementation<Responder, Executor>>(
-            this->grpc_context(), {request, options}, {*this}, token);
+            detail::ClientWriteBidiStreamingSenderImplementation<Responder>>(this->grpc_context(), {request, options},
+                                                                             {*this}, token);
     }
 
     /**
@@ -1042,9 +1005,8 @@ class ClientRPCBidiStreamingBase<ResponderT<RequestT, ResponseT>, Executor>
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
     auto writes_done(CompletionToken token = detail::DefaultCompletionTokenT<Executor>{})
     {
-        return detail::async_initiate_sender_implementation<
-            detail::ClientWritesDoneSenderImplementation<Responder, Executor>>(this->grpc_context(), {}, {*this},
-                                                                               token);
+        return detail::async_initiate_sender_implementation<detail::ClientWritesDoneSenderImplementation<Responder>>(
+            this->grpc_context(), {}, {*this}, token);
     }
 
     /**
@@ -1084,10 +1046,10 @@ class ClientRPCBidiStreamingBase<ResponderT<RequestT, ResponseT>, Executor>
     }
 
   private:
-    friend detail::ReadInitialMetadataSenderImplementation<ClientRPCBidiStreamingBase>;
-    friend detail::ClientReadBidiStreamingSenderImplementation<Responder, Executor>;
-    friend detail::ClientWriteBidiStreamingSenderImplementation<Responder, Executor>;
-    friend detail::ClientWritesDoneSenderImplementation<Responder, Executor>;
+    friend detail::ReadInitialMetadataSenderImplementation<Responder>;
+    friend detail::ClientReadBidiStreamingSenderImplementation<Responder>;
+    friend detail::ClientWriteBidiStreamingSenderImplementation<Responder>;
+    friend detail::ClientWritesDoneSenderImplementation<Responder>;
     friend detail::ClientFinishSenderImplementation<ClientRPCBidiStreamingBase>;
 };
 }
diff --git a/src/agrpc/detail/alarm.hpp b/src/agrpc/detail/alarm.hpp
index 3d72e0c3..0fff5474 100644
--- a/src/agrpc/detail/alarm.hpp
+++ b/src/agrpc/detail/alarm.hpp
@@ -38,9 +38,9 @@ struct MoveAlarmSenderImplementation
 
     auto& stop_function_arg(const Initiation&) noexcept { return alarm_.alarm_; }
 
-    void initiate(agrpc::GrpcContext& grpc_context, const Initiation& deadline, detail::OperationBase* operation)
+    void initiate(agrpc::GrpcContext& grpc_context, const Initiation& deadline, void* tag)
     {
-        detail::AlarmInitFunction{alarm_.alarm_, deadline}(grpc_context, operation);
+        detail::AlarmInitFunction{alarm_.alarm_, deadline}(grpc_context, tag);
     }
 
     template <class OnDone>
diff --git a/src/agrpc/detail/client_rpc_sender.hpp b/src/agrpc/detail/client_rpc_sender.hpp
index 0864c217..69d2ec6e 100644
--- a/src/agrpc/detail/client_rpc_sender.hpp
+++ b/src/agrpc/detail/client_rpc_sender.hpp
@@ -18,6 +18,7 @@
 #include <agrpc/detail/config.hpp>
 #include <agrpc/detail/grpc_sender.hpp>
 #include <agrpc/detail/rpc_client_context_base.hpp>
+#include <agrpc/detail/rpc_executor_base.hpp>
 #include <agrpc/detail/rpc_type.hpp>
 #include <agrpc/detail/utility.hpp>
 #include <agrpc/grpc_context.hpp>
@@ -26,31 +27,12 @@
 
 AGRPC_NAMESPACE_BEGIN()
 
-/**
- * @brief (experimental) Primary ClientRPC template
- *
- * This is the main entrypoint into the recommended API for writing asynchronous gRPC clients.
- *
- * @see
- * @c agrpc::ClientRPC<PrepareAsyncUnary,Executor> <br>
- * @c agrpc::ClientRPC<agrpc::ClientRPCType::GENERIC_UNARY,Executor> <br>
- * @c agrpc::ClientRPC<PrepareAsyncClientStreaming,Executor> <br>
- * @c agrpc::ClientRPC<PrepareAsyncServerStreaming,Executor> <br>
- * @c agrpc::ClientRPC<PrepareAsyncBidiStreaming,Executor> <br>
- * @c agrpc::ClientRPC<agrpc::ClientRPCType::GENERIC_STREAMING,Executor> <br>
- *
- * @since 2.6.0
- */
-template <auto PrepareAsync, class Executor = agrpc::GrpcExecutor>
-class ClientRPC;
-
 namespace detail
 {
 template <auto PrepareAsync, class Executor>
 class ClientRPCUnaryBase;
 
-template <auto PrepareAsync, class Executor>
-class ClientRPCServerStreamingBase;
+using ClientRPCAccess = AutoCancelClientContextAndResponderAccess;
 
 struct ClientContextCancellationFunction
 {
@@ -96,10 +78,10 @@ struct ClientUnaryRequestSenderImplementationBase<Responder<Response>>
 
     grpc::ClientContext& stop_function_arg(const Initiation& initiation) noexcept { return initiation.client_context_; }
 
-    void initiate(const agrpc::GrpcContext&, const Initiation& initiation, detail::OperationBase* operation) noexcept
+    void initiate(const agrpc::GrpcContext&, const Initiation& initiation, void* tag) noexcept
     {
         responder_->StartCall();
-        responder_->Finish(&initiation.response_, &status_, operation);
+        responder_->Finish(&initiation.response_, &status_, tag);
     }
 
     template <class OnDone>
@@ -150,12 +132,14 @@ struct ClientStreamingRequestSenderInitiation<PrepareAsync, Executor>
 {
     using RPC = agrpc::ClientRPC<PrepareAsync, Executor>;
 
-    RPC& rpc_;
-
     ClientStreamingRequestSenderInitiation(RPC& rpc, Stub& stub, Response& response) : rpc_(rpc)
     {
-        rpc.set_responder((stub.*PrepareAsync)(&rpc.context(), &response, rpc.grpc_context().get_completion_queue()));
+        ClientRPCAccess::set_responder(
+            rpc, (stub.*PrepareAsync)(&rpc.context(), &response,
+                                      RPCExecutorBaseAccess::grpc_context(rpc).get_completion_queue()));
     }
+
+    RPC& rpc_;
 };
 
 template <class Stub, class Request, class Response, template <class> class Responder,
@@ -165,12 +149,14 @@ struct ClientStreamingRequestSenderInitiation<PrepareAsync, Executor>
 {
     using RPC = detail::ClientRPCServerStreamingBase<PrepareAsync, Executor>;
 
-    RPC& rpc_;
-
     ClientStreamingRequestSenderInitiation(RPC& rpc, Stub& stub, const Request& req) : rpc_(rpc)
     {
-        rpc.set_responder((stub.*PrepareAsync)(&rpc.context(), req, rpc.grpc_context().get_completion_queue()));
+        ClientRPCAccess::set_responder(
+            rpc,
+            (stub.*PrepareAsync)(&rpc.context(), req, RPCExecutorBaseAccess::grpc_context(rpc).get_completion_queue()));
     }
+
+    RPC& rpc_;
 };
 
 template <class Stub, class Request, class Response, template <class, class> class Responder,
@@ -180,12 +166,13 @@ struct ClientStreamingRequestSenderInitiation<PrepareAsync, Executor>
 {
     using RPC = agrpc::ClientRPC<PrepareAsync, Executor>;
 
-    RPC& rpc_;
-
     ClientStreamingRequestSenderInitiation(RPC& rpc, Stub& stub) : rpc_(rpc)
     {
-        rpc.set_responder((stub.*PrepareAsync)(&rpc.context(), rpc.grpc_context().get_completion_queue()));
+        ClientRPCAccess::set_responder(
+            rpc, (stub.*PrepareAsync)(&rpc.context(), RPCExecutorBaseAccess::grpc_context(rpc).get_completion_queue()));
     }
+
+    RPC& rpc_;
 };
 
 template <class Executor>
@@ -193,12 +180,14 @@ struct ClientStreamingRequestSenderInitiation<agrpc::ClientRPCType::GENERIC_STRE
 {
     using RPC = agrpc::ClientRPC<agrpc::ClientRPCType::GENERIC_STREAMING, Executor>;
 
-    RPC& rpc_;
-
     ClientStreamingRequestSenderInitiation(RPC& rpc, const std::string& method, grpc::GenericStub& stub) : rpc_(rpc)
     {
-        rpc.set_responder(stub.PrepareCall(&rpc.context(), method, rpc.grpc_context().get_completion_queue()));
+        ClientRPCAccess::set_responder(
+            rpc,
+            stub.PrepareCall(&rpc.context(), method, RPCExecutorBaseAccess::grpc_context(rpc).get_completion_queue()));
     }
+
+    RPC& rpc_;
 };
 
 template <auto PrepareAsync, class Executor>
@@ -209,9 +198,9 @@ struct ClientStreamingRequestSenderImplementation : detail::GrpcSenderImplementa
 
     auto& stop_function_arg(const Initiation& initiation) noexcept { return initiation.rpc_.context(); }
 
-    static void initiate(const agrpc::GrpcContext&, const Initiation& initiation, void* self) noexcept
+    static void initiate(const agrpc::GrpcContext&, const Initiation& initiation, void* tag) noexcept
     {
-        initiation.rpc_.responder().StartCall(self);
+        ClientRPCAccess::responder(initiation.rpc_).StartCall(tag);
     }
 
     template <class OnDone>
@@ -221,9 +210,10 @@ struct ClientStreamingRequestSenderImplementation : detail::GrpcSenderImplementa
     }
 };
 
-template <class RPC>
+template <class Responder>
 struct ReadInitialMetadataSenderImplementation : detail::GrpcSenderImplementationBase
 {
+    using RPC = detail::AutoCancelClientContextAndResponder<Responder>;
     using Initiation = detail::Empty;
     using StopFunction = detail::ClientContextCancellationFunction;
 
@@ -231,9 +221,9 @@ struct ReadInitialMetadataSenderImplementation : detail::GrpcSenderImplementatio
 
     grpc::ClientContext& stop_function_arg(const Initiation&) noexcept { return rpc_.context(); }
 
-    void initiate(const agrpc::GrpcContext&, const Initiation&, void* self) noexcept
+    void initiate(const agrpc::GrpcContext&, const Initiation&, void* tag) noexcept
     {
-        rpc_.responder().ReadInitialMetadata(self);
+        ClientRPCAccess::responder(rpc_).ReadInitialMetadata(tag);
     }
 
     template <class OnDone>
@@ -245,23 +235,27 @@ struct ReadInitialMetadataSenderImplementation : detail::GrpcSenderImplementatio
     RPC& rpc_;
 };
 
-template <class RPC>
-struct ReadServerStreamingSenderImplementation : detail::GrpcSenderImplementationBase
+template <class Responder>
+struct ReadServerStreamingSenderImplementation;
+
+template <template <class> class Responder, class Response>
+struct ReadServerStreamingSenderImplementation<Responder<Response>> : detail::GrpcSenderImplementationBase
 {
+    using RPC = detail::AutoCancelClientContextAndResponder<Responder<Response>>;
     using StopFunction = detail::ClientContextCancellationFunction;
 
     struct Initiation
     {
-        typename RPC::Response& response_;
+        Response& response_;
     };
 
     ReadServerStreamingSenderImplementation(RPC& rpc) : rpc_(rpc) {}
 
     grpc::ClientContext& stop_function_arg(const Initiation&) noexcept { return rpc_.context(); }
 
-    void initiate(const agrpc::GrpcContext&, const Initiation& initiation, detail::OperationBase* operation) noexcept
+    void initiate(const agrpc::GrpcContext&, const Initiation& initiation, void* tag) noexcept
     {
-        rpc_.responder().Read(&initiation.response_, operation);
+        ClientRPCAccess::responder(rpc_).Read(&initiation.response_, tag);
     }
 
     template <class OnDone>
@@ -273,14 +267,18 @@ struct ReadServerStreamingSenderImplementation : detail::GrpcSenderImplementatio
     RPC& rpc_;
 };
 
-template <class RPC>
-struct WriteClientStreamingSenderImplementation : detail::GrpcSenderImplementationBase
+template <class Responder>
+struct WriteClientStreamingSenderImplementation;
+
+template <template <class> class Responder, class Request>
+struct WriteClientStreamingSenderImplementation<Responder<Request>> : detail::GrpcSenderImplementationBase
 {
+    using RPC = detail::AutoCancelClientContextAndResponder<Responder<Request>>;
     using StopFunction = detail::ClientContextCancellationFunction;
 
     struct Initiation
     {
-        const typename RPC::Request& request_;
+        const Request& request_;
         grpc::WriteOptions options_;
     };
 
@@ -288,17 +286,17 @@ struct WriteClientStreamingSenderImplementation : detail::GrpcSenderImplementati
 
     grpc::ClientContext& stop_function_arg(const Initiation&) noexcept { return rpc_.context(); }
 
-    void initiate(const agrpc::GrpcContext&, const Initiation& initiation, void* self) noexcept
+    void initiate(const agrpc::GrpcContext&, const Initiation& initiation, void* tag) noexcept
     {
         auto& [req, options] = initiation;
         if (options.is_last_message())
         {
-            rpc_.set_writes_done();
-            rpc_.responder().Write(req, options, self);
+            ClientRPCAccess::set_writes_done(rpc_);
+            ClientRPCAccess::responder(rpc_).Write(req, options, tag);
         }
         else
         {
-            rpc_.responder().Write(req, options, self);
+            ClientRPCAccess::responder(rpc_).Write(req, options, tag);
         }
     }
 
@@ -311,14 +309,13 @@ struct WriteClientStreamingSenderImplementation : detail::GrpcSenderImplementati
     RPC& rpc_;
 };
 
-template <class Responder, class Executor>
+template <class Responder>
 struct ClientReadBidiStreamingSenderImplementation;
 
-template <template <class, class> class Responder, class Request, class Response, class Executor>
-struct ClientReadBidiStreamingSenderImplementation<Responder<Request, Response>, Executor>
-    : detail::GrpcSenderImplementationBase
+template <template <class, class> class Responder, class Request, class Response>
+struct ClientReadBidiStreamingSenderImplementation<Responder<Request, Response>> : detail::GrpcSenderImplementationBase
 {
-    using RPCBase = detail::ClientRPCBidiStreamingBase<Responder<Request, Response>, Executor>;
+    using RPCBase = detail::AutoCancelClientContextAndResponder<Responder<Request, Response>>;
     using StopFunction = detail::ClientContextCancellationFunction;
 
     struct Initiation
@@ -330,9 +327,9 @@ struct ClientReadBidiStreamingSenderImplementation<Responder<Request, Response>,
 
     grpc::ClientContext& stop_function_arg(const Initiation&) noexcept { return rpc_.context(); }
 
-    void initiate(const agrpc::GrpcContext&, const Initiation& initiation, detail::OperationBase* operation) noexcept
+    void initiate(const agrpc::GrpcContext&, const Initiation& initiation, void* tag) noexcept
     {
-        rpc_.responder().Read(&initiation.response_, operation);
+        ClientRPCAccess::responder(rpc_).Read(&initiation.response_, tag);
     }
 
     template <class OnDone>
@@ -344,14 +341,13 @@ struct ClientReadBidiStreamingSenderImplementation<Responder<Request, Response>,
     RPCBase& rpc_;
 };
 
-template <class Responder, class Executor>
+template <class Responder>
 struct ClientWriteBidiStreamingSenderImplementation;
 
-template <template <class, class> class Responder, class Request, class Response, class Executor>
-struct ClientWriteBidiStreamingSenderImplementation<Responder<Request, Response>, Executor>
-    : detail::GrpcSenderImplementationBase
+template <template <class, class> class Responder, class Request, class Response>
+struct ClientWriteBidiStreamingSenderImplementation<Responder<Request, Response>> : detail::GrpcSenderImplementationBase
 {
-    using RPCBase = detail::ClientRPCBidiStreamingBase<Responder<Request, Response>, Executor>;
+    using RPCBase = detail::AutoCancelClientContextAndResponder<Responder<Request, Response>>;
     using StopFunction = detail::ClientContextCancellationFunction;
 
     struct Initiation
@@ -364,14 +360,14 @@ struct ClientWriteBidiStreamingSenderImplementation<Responder<Request, Response>
 
     grpc::ClientContext& stop_function_arg(const Initiation&) noexcept { return rpc_.context(); }
 
-    void initiate(const agrpc::GrpcContext&, const Initiation& initiation, detail::OperationBase* operation) noexcept
+    void initiate(const agrpc::GrpcContext&, const Initiation& initiation, void* tag) noexcept
     {
         auto& [req, options] = initiation;
         if (options.is_last_message())
         {
-            rpc_.set_writes_done();
+            ClientRPCAccess::set_writes_done(rpc_);
         }
-        rpc_.responder().Write(req, options, operation);
+        ClientRPCAccess::responder(rpc_).Write(req, options, tag);
     }
 
     template <class OnDone>
@@ -383,14 +379,10 @@ struct ClientWriteBidiStreamingSenderImplementation<Responder<Request, Response>
     RPCBase& rpc_;
 };
 
-template <class Responder, class Executor>
-struct ClientWritesDoneSenderImplementation;
-
-template <template <class, class> class Responder, class Request, class Response, class Executor>
-struct ClientWritesDoneSenderImplementation<Responder<Request, Response>, Executor>
-    : detail::GrpcSenderImplementationBase
+template <class Responder>
+struct ClientWritesDoneSenderImplementation : detail::GrpcSenderImplementationBase
 {
-    using RPCBase = detail::ClientRPCBidiStreamingBase<Responder<Request, Response>, Executor>;
+    using RPCBase = detail::AutoCancelClientContextAndResponder<Responder>;
     using Initiation = detail::Empty;
     using StopFunction = detail::ClientContextCancellationFunction;
 
@@ -398,15 +390,15 @@ struct ClientWritesDoneSenderImplementation<Responder<Request, Response>, Execut
 
     grpc::ClientContext& stop_function_arg(const Initiation&) noexcept { return rpc_.context(); }
 
-    void initiate(const agrpc::GrpcContext&, const Initiation&, void* self) noexcept
+    void initiate(const agrpc::GrpcContext&, const Initiation&, void* tag) noexcept
     {
-        rpc_.responder().WritesDone(self);
+        ClientRPCAccess::responder(rpc_).WritesDone(tag);
     }
 
     template <class OnDone>
     void done(OnDone on_done, bool ok)
     {
-        rpc_.set_writes_done();
+        ClientRPCAccess::set_writes_done(rpc_);
         on_done(ok);
     }
 
@@ -429,27 +421,27 @@ struct ClientFinishSenderImplementation
     template <class Init>
     void initiate(Init init, const Initiation&) noexcept
     {
-        if (rpc_.is_writes_done())
+        if (ClientRPCAccess::is_writes_done(rpc_))
         {
-            rpc_.responder().Finish(&status_, init.template self<1>());
+            ClientRPCAccess::responder(rpc_).Finish(&status_, init.template self<1>());
         }
         else
         {
-            rpc_.responder().WritesDone(init.template self<0>());
+            ClientRPCAccess::responder(rpc_).WritesDone(init.template self<0>());
         }
     }
 
     template <template <int> class OnDone>
     void done(OnDone<0> on_done, bool)
     {
-        rpc_.grpc_context().work_started();
-        rpc_.responder().Finish(&status_, on_done.template self<1>());
+        RPCExecutorBaseAccess::grpc_context(rpc_).work_started();
+        ClientRPCAccess::responder(rpc_).Finish(&status_, on_done.template self<1>());
     }
 
     template <template <int> class OnDone>
     void done(OnDone<1> on_done, bool)
     {
-        rpc_.set_finished();
+        ClientRPCAccess::set_finished(rpc_);
         on_done(static_cast<grpc::Status&&>(status_));
     }
 
@@ -457,7 +449,7 @@ struct ClientFinishSenderImplementation
     grpc::Status status_{};
 };
 
-template <class RPC>
+template <class Responder>
 struct ClientFinishServerStreamingSenderImplementation
 {
     static constexpr auto TYPE = detail::SenderImplementationType::GRPC_TAG;
@@ -468,19 +460,19 @@ struct ClientFinishServerStreamingSenderImplementation
 
     grpc::ClientContext& stop_function_arg(const Initiation&) noexcept { return rpc_.context(); }
 
-    void initiate(const agrpc::GrpcContext&, const Initiation&, void* self) noexcept
+    void initiate(const agrpc::GrpcContext&, const Initiation&, void* tag) noexcept
     {
-        rpc_.responder().Finish(&status_, self);
+        ClientRPCAccess::responder(rpc_).Finish(&status_, tag);
     }
 
     template <class OnDone>
     void done(OnDone on_done, bool)
     {
-        rpc_.set_finished();
+        ClientRPCAccess::set_finished(rpc_);
         on_done(static_cast<grpc::Status&&>(status_));
     }
 
-    RPC& rpc_;
+    detail::AutoCancelClientContextAndResponder<Responder>& rpc_;
     grpc::Status status_{};
 };
 }
diff --git a/src/agrpc/detail/forward.hpp b/src/agrpc/detail/forward.hpp
index 93708689..9556b8d0 100644
--- a/src/agrpc/detail/forward.hpp
+++ b/src/agrpc/detail/forward.hpp
@@ -38,6 +38,24 @@ class BasicAlarm;
 
 struct UseSender;
 
+/**
+ * @brief (experimental) Primary ClientRPC template
+ *
+ * This is the main entrypoint into the recommended API for writing asynchronous gRPC clients.
+ *
+ * @see
+ * @c agrpc::ClientRPC<PrepareAsyncUnary,Executor> <br>
+ * @c agrpc::ClientRPC<agrpc::ClientRPCType::GENERIC_UNARY,Executor> <br>
+ * @c agrpc::ClientRPC<PrepareAsyncClientStreaming,Executor> <br>
+ * @c agrpc::ClientRPC<PrepareAsyncServerStreaming,Executor> <br>
+ * @c agrpc::ClientRPC<PrepareAsyncBidiStreaming,Executor> <br>
+ * @c agrpc::ClientRPC<agrpc::ClientRPCType::GENERIC_STREAMING,Executor> <br>
+ *
+ * @since 2.6.0
+ */
+template <auto PrepareAsync, class Executor = agrpc::BasicGrpcExecutor<>>
+class ClientRPC;
+
 namespace detail
 {
 template <class Item>
@@ -66,9 +84,16 @@ class ServerWriteReactor;
 template <class Deadline, class Executor>
 struct MoveAlarmSenderImplementation;
 
+template <auto PrepareAsync, class Executor>
+class ClientRPCServerStreamingBase;
+
 template <class Responder, class Executor>
 class ClientRPCBidiStreamingBase;
 
+struct AutoCancelClientContextAndResponderAccess;
+
+struct RPCExecutorBaseAccess;
+
 AGRPC_NAMESPACE_CPP20_BEGIN()
 
 class RepeatedlyRequestFn;
diff --git a/src/agrpc/detail/grpc_sender.hpp b/src/agrpc/detail/grpc_sender.hpp
index 2ea74d4e..02de185e 100644
--- a/src/agrpc/detail/grpc_sender.hpp
+++ b/src/agrpc/detail/grpc_sender.hpp
@@ -38,10 +38,9 @@ struct GrpcSenderImplementation : detail::GrpcSenderImplementationBase
 
     static auto& stop_function_arg(const Initiation& initiation) noexcept { return initiation; }
 
-    static void initiate(agrpc::GrpcContext& grpc_context, const Initiation& initiation,
-                         detail::OperationBase* operation)
+    static void initiate(agrpc::GrpcContext& grpc_context, const Initiation& initiation, detail::OperationBase* self)
     {
-        initiation(grpc_context, operation);
+        initiation(grpc_context, self);
     }
 
     template <class OnDone>
diff --git a/src/agrpc/detail/rpc_client_context_base.hpp b/src/agrpc/detail/rpc_client_context_base.hpp
index f318efa1..bde9c29c 100644
--- a/src/agrpc/detail/rpc_client_context_base.hpp
+++ b/src/agrpc/detail/rpc_client_context_base.hpp
@@ -81,9 +81,8 @@ class AutoCancelClientContextAndResponder
 
     AutoCancelClientContextAndResponder& operator=(AutoCancelClientContextAndResponder&& other) = delete;
 
-    [[nodiscard]] Responder& responder() noexcept { return *responder_; }
-
-    void set_responder(std::unique_ptr<Responder> responder) noexcept { responder_.set(responder.release()); }
+  private:
+    friend struct detail::AutoCancelClientContextAndResponderAccess;
 
     [[nodiscard]] bool is_finished() const noexcept { return responder_.template has_bit<0>(); }
 
@@ -93,10 +92,49 @@ class AutoCancelClientContextAndResponder
 
     void set_writes_done() noexcept { responder_.template set_bit<1>(); }
 
-  private:
     grpc::ClientContext client_context_{};
     detail::AtomicTaggedPtr<Responder> responder_{};
 };
+
+struct AutoCancelClientContextAndResponderAccess
+{
+    template <class Responder>
+    static Responder& responder(AutoCancelClientContextAndResponder<Responder>& rpc) noexcept
+    {
+        return *rpc.responder_;
+    }
+
+    template <class Responder>
+    static void set_responder(AutoCancelClientContextAndResponder<Responder>& rpc,
+                              std::unique_ptr<Responder> responder) noexcept
+    {
+        rpc.responder_.set(responder.release());
+    }
+
+    template <class Responder>
+    [[nodiscard]] static bool is_finished(AutoCancelClientContextAndResponder<Responder>& rpc) noexcept
+    {
+        return rpc.is_finished();
+    }
+
+    template <class Responder>
+    static void set_finished(AutoCancelClientContextAndResponder<Responder>& rpc) noexcept
+    {
+        rpc.set_finished();
+    }
+
+    template <class Responder>
+    [[nodiscard]] static bool is_writes_done(AutoCancelClientContextAndResponder<Responder>& rpc) noexcept
+    {
+        return rpc.is_writes_done();
+    }
+
+    template <class Responder>
+    static void set_writes_done(AutoCancelClientContextAndResponder<Responder>& rpc) noexcept
+    {
+        rpc.set_writes_done();
+    }
+};
 }
 
 AGRPC_NAMESPACE_END
diff --git a/src/agrpc/detail/rpc_executor_base.hpp b/src/agrpc/detail/rpc_executor_base.hpp
new file mode 100644
index 00000000..4229f969
--- /dev/null
+++ b/src/agrpc/detail/rpc_executor_base.hpp
@@ -0,0 +1,82 @@
+// Copyright 2022 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
+//
+//     http://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_RPC_EXECUTOR_BASE_HPP
+#define AGRPC_DETAIL_RPC_EXECUTOR_BASE_HPP
+
+#include <agrpc/detail/config.hpp>
+#include <agrpc/detail/forward.hpp>
+#include <agrpc/detail/query_grpc_context.hpp>
+#include <agrpc/detail/tagged_ptr.hpp>
+#include <agrpc/grpc_executor.hpp>
+
+AGRPC_NAMESPACE_BEGIN()
+
+namespace detail
+{
+/**
+ * @brief (experimental) RPC's executor base
+ *
+ * @since 2.1.0
+ */
+template <class Executor>
+class RPCExecutorBase
+{
+  public:
+    /**
+     * @brief The executor type
+     */
+    using executor_type = Executor;
+
+    /**
+     * @brief Get the executor
+     *
+     * Thread-safe
+     */
+    [[nodiscard]] const executor_type& get_executor() const noexcept { return executor_; }
+
+  private:
+    template <auto, class>
+    friend class agrpc::ClientRPC;
+
+    template <auto, class>
+    friend class detail::ClientRPCServerStreamingBase;
+
+    template <class, class>
+    friend class detail::ClientRPCBidiStreamingBase;
+
+    friend struct detail::RPCExecutorBaseAccess;
+
+    RPCExecutorBase() : executor_(agrpc::GrpcExecutor{}) {}
+
+    explicit RPCExecutorBase(const Executor& executor) : executor_(executor) {}
+
+    auto& grpc_context() const noexcept { return detail::query_grpc_context(executor_); }
+
+    Executor executor_;
+};
+
+struct RPCExecutorBaseAccess
+{
+    template <class Executor>
+    static agrpc::GrpcContext& grpc_context(detail::RPCExecutorBase<Executor>& rpc) noexcept
+    {
+        return rpc.grpc_context();
+    }
+};
+}
+
+AGRPC_NAMESPACE_END
+
+#endif  // AGRPC_DETAIL_RPC_EXECUTOR_BASE_HPP
diff --git a/test/src/test_client_rpc_17.cpp b/test/src/test_client_rpc_17.cpp
index f531416d..3c52ed45 100644
--- a/test/src/test_client_rpc_17.cpp
+++ b/test/src/test_client_rpc_17.cpp
@@ -129,7 +129,7 @@ TEST_CASE_FIXTURE(test::ClientRPCTest<test::ServerStreamingClientRPC>,
                     test::Exception);
 }
 
-TEST_CASE_TEMPLATE("RPC::read_initial_metadata successfully", RPC, test::ClientStreamingClientRPC,
+TEST_CASE_TEMPLATE("ClientRPC::read_initial_metadata successfully", RPC, test::ClientStreamingClientRPC,
                    test::ServerStreamingClientRPC, test::BidirectionalStreamingClientRPC)
 {
     test::ClientRPCTest<RPC> test;
@@ -147,7 +147,7 @@ TEST_CASE_TEMPLATE("RPC::read_initial_metadata successfully", RPC, test::ClientS
         });
 }
 
-TEST_CASE_TEMPLATE("RPC::read_initial_metadata on cancelled RPC", RPC, test::ClientStreamingClientRPC,
+TEST_CASE_TEMPLATE("ClientRPC::read_initial_metadata on cancelled RPC", RPC, test::ClientStreamingClientRPC,
                    test::ServerStreamingClientRPC)
 {
     test::ClientRPCTest<RPC> test;
@@ -169,7 +169,7 @@ TEST_CASE_TEMPLATE("RPC::read_initial_metadata on cancelled RPC", RPC, test::Cli
 
 #ifdef AGRPC_ASIO_HAS_SENDER_RECEIVER
 TEST_CASE_FIXTURE(test::ClientRPCTest<test::UnaryClientRPC>,
-                  "RPC::request can have UseSender as default completion token")
+                  "ClientRPC::request can have UseSender as default completion token")
 {
     using RPC = agrpc::UseSender::as_default_on_t<agrpc::ClientRPC<&test::v1::Test::Stub::PrepareAsyncUnary>>;
     bool ok{};
@@ -214,7 +214,7 @@ TEST_CASE_FIXTURE(test::ClientRPCTest<test::UnaryClientRPC>,
 }
 #endif
 
-TEST_CASE_FIXTURE(test::ClientRPCTest<test::GenericUnaryClientRPC>, "RPC::request generic unary RPC successfully")
+TEST_CASE_FIXTURE(test::ClientRPCTest<test::GenericUnaryClientRPC>, "ClientRPC::request generic unary RPC successfully")
 {
     bool use_executor_overload{};
     SUBCASE("executor overload") {}
@@ -585,7 +585,7 @@ TEST_CASE_FIXTURE(ClientRPCIoContextTest<test::GenericStreamingClientRPC>, "Gene
         });
 }
 
-TEST_CASE("RPC::service_name/method_name")
+TEST_CASE("ClientRPC::service_name/method_name")
 {
     const auto check_eq_and_null_terminated = [](std::string_view expected, std::string_view actual)
     {
@@ -602,6 +602,20 @@ TEST_CASE("RPC::service_name/method_name")
     check_eq_and_null_terminated("BidirectionalStreaming", test::BidirectionalStreamingClientRPC::method_name());
 }
 
+struct Derived : test::ServerStreamingClientRPC
+{
+    template <class T = test::ServerStreamingClientRPC>
+    auto is_finished(int) -> decltype((void)T::is_finished(), std::true_type{});
+
+    template <class T = test::ServerStreamingClientRPC>
+    auto is_finished(long) -> std::false_type;
+};
+
+TEST_CASE("ClientRPC derived class cannot access private base member")
+{
+    CHECK_FALSE(decltype(std::declval<Derived>().is_finished(0))::value);
+}
+
 #ifdef AGRPC_ASIO_HAS_CANCELLATION_SLOT
 template <class RPC>
 struct ClientRPCCancellationTest : test::ClientRPCTest<RPC>, test::IoContextTest
@@ -753,9 +767,9 @@ void test_rpc_step_functions_can_be_cancelled()
     CHECK_LT(test::now(), not_to_exceed);
 }
 
-TEST_CASE_TEMPLATE("RPC::read_initial_metadata can be cancelled", T, ClientStreamingReadInitialMetadataCancellation,
-                   ServerStreamingReadInitialMetadataCancellation, BidiStreamingReadInitialMetadataCancellation,
-                   GenericBidiStreamingReadInitialMetadataCancellation)
+TEST_CASE_TEMPLATE("ClientRPC::read_initial_metadata can be cancelled", T,
+                   ClientStreamingReadInitialMetadataCancellation, ServerStreamingReadInitialMetadataCancellation,
+                   BidiStreamingReadInitialMetadataCancellation, GenericBidiStreamingReadInitialMetadataCancellation)
 {
     if (grpc::Version() > "1.20.0")
     {