diff --git a/src/agrpc/alarm.hpp b/src/agrpc/alarm.hpp
index b832556b..bd3c73d2 100644
--- a/src/agrpc/alarm.hpp
+++ b/src/agrpc/alarm.hpp
@@ -80,7 +80,7 @@ class BasicAlarm
      * completion signature is `void(bool)`. `true` if it expired, `false` if it was canceled.
      */
     template <class Deadline, class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto wait(const Deadline& deadline, CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{}) &
+    auto wait(const Deadline& deadline, CompletionToken&& token = CompletionToken{}) &
     {
         using Initiation = detail::GrpcSenderInitiation<detail::AlarmInitFunction<Deadline>>;
         if constexpr (std::is_same_v<agrpc::UseSender, detail::RemoveCrefT<CompletionToken>>)
@@ -110,7 +110,7 @@ class BasicAlarm
      * completion signature is `void(bool, BasicAlarm)`. `true` if it expired, `false` if it was canceled.
      */
     template <class Deadline, class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto wait(const Deadline& deadline, CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{}) &&
+    auto wait(const Deadline& deadline, CompletionToken&& token = CompletionToken{}) &&
     {
         using Initiation = detail::MoveAlarmSenderInitiation<Deadline>;
         if constexpr (std::is_same_v<agrpc::UseSender, detail::RemoveCrefT<CompletionToken>>)
diff --git a/src/agrpc/client_rpc.hpp b/src/agrpc/client_rpc.hpp
index 8fa63a7d..d2a8ddc1 100644
--- a/src/agrpc/client_rpc.hpp
+++ b/src/agrpc/client_rpc.hpp
@@ -129,8 +129,7 @@ class ClientRPCUnaryBase<PrepareAsyncUnary, Executor> : public detail::ClientRPC
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
     static auto request(agrpc::GrpcContext& grpc_context, StubT& stub, grpc::ClientContext& context,
-                        const RequestT& request, ResponseT& response,
-                        CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+                        const RequestT& request, ResponseT& response, CompletionToken&& token = CompletionToken{})
     {
         return detail::async_initiate_sender_implementation(
             grpc_context, detail::ClientUnaryRequestSenderInitiation<ResponseT>{context, response},
@@ -143,7 +142,7 @@ class ClientRPCUnaryBase<PrepareAsyncUnary, Executor> : public detail::ClientRPC
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
     static auto request(const Executor& executor, StubT& stub, grpc::ClientContext& context, const RequestT& request,
-                        ResponseT& response, CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+                        ResponseT& response, CompletionToken&& token = CompletionToken{})
     {
         return ClientRPCUnaryBase::request(detail::query_grpc_context(executor), stub, context, request, response,
                                            static_cast<CompletionToken&&>(token));
@@ -184,7 +183,7 @@ class ClientRPCUnaryBase<PrepareAsyncUnary, Executor> : public detail::ClientRPC
      * completion signature is `void(grpc::Status)`.
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto finish(ResponseT& response, CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+    auto finish(ResponseT& response, CompletionToken&& token = CompletionToken{})
     {
         return detail::async_initiate_sender_implementation(
             this->grpc_context(), detail::ClientFinishUnarySenderInitation<Response>{response},
@@ -320,7 +319,7 @@ class ClientRPC<agrpc::ClientRPCType::GENERIC_UNARY, Executor>
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
     static auto request(agrpc::GrpcContext& grpc_context, const std::string& method, grpc::GenericStub& stub,
                         grpc::ClientContext& context, const grpc::ByteBuffer& request, grpc::ByteBuffer& response,
-                        CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+                        CompletionToken&& token = CompletionToken{})
     {
         return detail::async_initiate_sender_implementation(
             grpc_context, detail::ClientUnaryRequestSenderInitiation<Response>{context, response},
@@ -334,7 +333,7 @@ class ClientRPC<agrpc::ClientRPCType::GENERIC_UNARY, Executor>
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
     static auto request(const Executor& executor, const std::string& method, grpc::GenericStub& stub,
                         grpc::ClientContext& context, const grpc::ByteBuffer& request, grpc::ByteBuffer& response,
-                        CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+                        CompletionToken&& token = CompletionToken{})
     {
         return ClientRPC::request(detail::query_grpc_context(executor), method, stub, context, request, response,
                                   static_cast<CompletionToken&&>(token));
@@ -376,7 +375,7 @@ class ClientRPC<agrpc::ClientRPCType::GENERIC_UNARY, Executor>
      * completion signature is `void(grpc::Status)`.
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto finish(grpc::ByteBuffer& response, CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+    auto finish(grpc::ByteBuffer& response, CompletionToken&& token = CompletionToken{})
     {
         return detail::async_initiate_sender_implementation(
             this->grpc_context(), detail::ClientFinishUnarySenderInitation<Response>{response},
@@ -513,7 +512,7 @@ class ClientRPC<PrepareAsyncClientStreaming, Executor> : public detail::ClientRP
      * error details.
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto start(StubT& stub, ResponseT& response, CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+    auto start(StubT& stub, ResponseT& response, CompletionToken&& token = CompletionToken{})
     {
         return detail::async_initiate_sender_implementation(
             this->grpc_context(),
@@ -542,7 +541,7 @@ class ClientRPC<PrepareAsyncClientStreaming, Executor> : public detail::ClientRP
      * `void(bool)`. `true` indicates that the metadata was read. If it is `false`, then the call is dead.
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto read_initial_metadata(CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+    auto read_initial_metadata(CompletionToken&& token = CompletionToken{})
     {
         return detail::async_initiate_sender_implementation(
             this->grpc_context(), detail::ClientReadInitialMetadataWritableStreamSenderInitiation{},
@@ -557,8 +556,7 @@ class ClientRPC<PrepareAsyncClientStreaming, Executor> : public detail::ClientRP
      * `write(request, token)`.
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto write(const RequestT& request, grpc::WriteOptions options,
-               CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+    auto write(const RequestT& request, grpc::WriteOptions options, CompletionToken&& token = CompletionToken{})
     {
         return detail::async_initiate_sender_implementation(
             this->grpc_context(), detail::ClientWriteSenderInitiation<RequestT>{request, options},
@@ -578,7 +576,7 @@ class ClientRPC<PrepareAsyncClientStreaming, Executor> : public detail::ClientRP
      * channel, etc).
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto write(const RequestT& request, CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+    auto write(const RequestT& request, CompletionToken&& token = CompletionToken{})
     {
         return write(request, grpc::WriteOptions{}, static_cast<CompletionToken&&>(token));
     }
@@ -608,7 +606,7 @@ class ClientRPC<PrepareAsyncClientStreaming, Executor> : public detail::ClientRP
      * completion signature is `void(grpc::Status)`.
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto finish(CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+    auto finish(CompletionToken&& token = CompletionToken{})
     {
         return detail::async_initiate_sender_implementation(
             this->grpc_context(), detail::ClientFinishWritableStreamSenderInitiation{},
@@ -715,8 +713,7 @@ class ClientRPCServerStreamingBase<PrepareAsyncServerStreaming, Executor>
      * error details.
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto start(StubT& stub, const RequestT& request,
-               CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+    auto start(StubT& stub, const RequestT& request, CompletionToken&& token = CompletionToken{})
     {
         return detail::async_initiate_sender_implementation(
             this->grpc_context(),
@@ -736,7 +733,7 @@ class ClientRPCServerStreamingBase<PrepareAsyncServerStreaming, Executor>
      * stream has failed (or been cancelled).
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto read(ResponseT& response, CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+    auto read(ResponseT& response, CompletionToken&& token = CompletionToken{})
     {
         return detail::async_initiate_sender_implementation(
             this->grpc_context(), detail::ClientReadSenderInitiation<Responder>{*this, response},
@@ -772,7 +769,7 @@ class ClientRPCServerStreamingBase<PrepareAsyncServerStreaming, Executor>
      * completion signature is `void(grpc::Status)`.
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto finish(CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+    auto finish(CompletionToken&& token = CompletionToken{})
     {
         return detail::async_initiate_sender_implementation(
             this->grpc_context(), detail::ClientFinishServerStreamingSenderInitation{},
@@ -873,7 +870,7 @@ class ClientRPCBidiStreamingBase<ResponderT<RequestT, ResponseT>, Executor>
      * `void(bool)`. `true` indicates that the metadata was read. If it is `false`, then the call is dead.
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto read_initial_metadata(CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+    auto read_initial_metadata(CompletionToken&& token = CompletionToken{})
     {
         return detail::async_initiate_sender_implementation(
             this->grpc_context(), detail::ClientReadInitialMetadataWritableStreamSenderInitiation{},
@@ -894,7 +891,7 @@ class ClientRPCBidiStreamingBase<ResponderT<RequestT, ResponseT>, Executor>
      * stream has failed (or been cancelled).
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto read(ResponseT& response, CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+    auto read(ResponseT& response, CompletionToken&& token = CompletionToken{})
     {
         return detail::async_initiate_sender_implementation(
             this->grpc_context(), detail::ClientReadSenderInitiation<Responder>{*this, response},
@@ -915,8 +912,7 @@ class ClientRPCBidiStreamingBase<ResponderT<RequestT, ResponseT>, Executor>
      * channel, etc).
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto write(const RequestT& request, grpc::WriteOptions options,
-               CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+    auto write(const RequestT& request, grpc::WriteOptions options, CompletionToken&& token = CompletionToken{})
     {
         return detail::async_initiate_sender_implementation(
             this->grpc_context(), detail::ClientWriteSenderInitiation<RequestT>{request, options},
@@ -927,7 +923,7 @@ class ClientRPCBidiStreamingBase<ResponderT<RequestT, ResponseT>, Executor>
      * @brief Send a message to the server (default WriteOptions)
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto write(const RequestT& request, CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+    auto write(const RequestT& request, CompletionToken&& token = CompletionToken{})
     {
         return write(request, grpc::WriteOptions{}, static_cast<CompletionToken&&>(token));
     }
@@ -949,7 +945,7 @@ class ClientRPCBidiStreamingBase<ResponderT<RequestT, ResponseT>, Executor>
      * wire because the call is already dead (i.e., canceled, deadline expired, other side dropped the channel, etc).
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto writes_done(CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+    auto writes_done(CompletionToken&& token = CompletionToken{})
     {
         return detail::async_initiate_sender_implementation(
             this->grpc_context(), detail::ClientWritesDoneSenderInitiation{},
@@ -985,7 +981,7 @@ class ClientRPCBidiStreamingBase<ResponderT<RequestT, ResponseT>, Executor>
      * completion signature is `void(grpc::Status)`.
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto finish(CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+    auto finish(CompletionToken&& token = CompletionToken{})
     {
         return detail::async_initiate_sender_implementation(
             this->grpc_context(), detail::ClientFinishWritableStreamSenderInitiation{},
@@ -1096,7 +1092,7 @@ class ClientRPC<PrepareAsyncBidiStreaming, Executor>
      * error details.
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto start(StubT& stub, CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+    auto start(StubT& stub, CompletionToken&& token = CompletionToken{})
     {
         return detail::async_initiate_sender_implementation(
             this->grpc_context(),
@@ -1158,8 +1154,7 @@ class ClientRPC<agrpc::ClientRPCType::GENERIC_STREAMING, Executor>
      * error details.
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto start(const std::string& method, grpc::GenericStub& stub,
-               CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+    auto start(const std::string& method, grpc::GenericStub& stub, CompletionToken&& token = CompletionToken{})
     {
         return detail::async_initiate_sender_implementation(
             this->grpc_context(),
diff --git a/src/agrpc/detail/grpc_context_implementation.hpp b/src/agrpc/detail/grpc_context_implementation.hpp
index 097b529e..f75be6d2 100644
--- a/src/agrpc/detail/grpc_context_implementation.hpp
+++ b/src/agrpc/detail/grpc_context_implementation.hpp
@@ -99,8 +99,7 @@ struct DoOneResult : CompletionQueueEventResult
 
     static DoOneResult from(CompletionQueueEventResult handled_event, bool processed_local_work) noexcept
     {
-        return {{static_cast<uint32_t>(handled_event.flags_ |
-                                       (processed_local_work ? DoOneResult::PROCESSED_LOCAL_WORK : uint32_t{}))}};
+        return {{handled_event.flags_ | (processed_local_work ? DoOneResult::PROCESSED_LOCAL_WORK : uint32_t{})}};
     }
 
     explicit operator bool() const noexcept { return processed_local_work() || handled_event(); }
diff --git a/src/agrpc/detail/register_rpc_handler_asio_base.hpp b/src/agrpc/detail/register_rpc_handler_asio_base.hpp
index 4c285bc1..34c4d5a1 100644
--- a/src/agrpc/detail/register_rpc_handler_asio_base.hpp
+++ b/src/agrpc/detail/register_rpc_handler_asio_base.hpp
@@ -18,7 +18,7 @@
 #include <agrpc/detail/association.hpp>
 #include <agrpc/detail/register_rpc_handler_base.hpp>
 #include <agrpc/detail/rethrow_first_arg.hpp>
-#include <agrpc/detail/rpc_request.hpp>
+#include <agrpc/detail/server_rpc_starter.hpp>
 #include <agrpc/detail/work_tracking_completion_handler.hpp>
 #include <agrpc/grpc_context.hpp>
 
@@ -104,7 +104,7 @@ struct RegisterRPCHandlerInitiator
             .release();
     }
 
-    detail::GetServerRPCServiceT<ServerRPC>& service_;
+    detail::ServerRPCServiceT<ServerRPC>& service_;
 };
 
 template <class Operation>
diff --git a/src/agrpc/detail/register_rpc_handler_base.hpp b/src/agrpc/detail/register_rpc_handler_base.hpp
index 811bd5ac..82ab62cb 100644
--- a/src/agrpc/detail/register_rpc_handler_base.hpp
+++ b/src/agrpc/detail/register_rpc_handler_base.hpp
@@ -45,7 +45,7 @@ class RegisterRPCHandlerOperationComplete
 template <class ServerRPC, class RPCHandler, class StopToken>
 struct RegisterRPCHandlerOperationBase
 {
-    using Service = detail::GetServerRPCServiceT<ServerRPC>;
+    using Service = detail::ServerRPCServiceT<ServerRPC>;
     using ServerRPCExecutor = typename ServerRPC::executor_type;
 
     RegisterRPCHandlerOperationBase(const ServerRPCExecutor& executor, Service& service, RPCHandler&& rpc_handler)
diff --git a/src/agrpc/detail/register_sender_rpc_handler.hpp b/src/agrpc/detail/register_sender_rpc_handler.hpp
index 5a5fdb29..e48de6e7 100644
--- a/src/agrpc/detail/register_sender_rpc_handler.hpp
+++ b/src/agrpc/detail/register_sender_rpc_handler.hpp
@@ -20,9 +20,9 @@
 #include <agrpc/detail/execution.hpp>
 #include <agrpc/detail/forward.hpp>
 #include <agrpc/detail/register_rpc_handler_base.hpp>
-#include <agrpc/detail/rpc_request.hpp>
 #include <agrpc/detail/sender_of.hpp>
 #include <agrpc/detail/server_rpc_context_base.hpp>
+#include <agrpc/detail/server_rpc_starter.hpp>
 #include <agrpc/detail/utility.hpp>
 #include <agrpc/grpc_context.hpp>
 
@@ -51,7 +51,7 @@ template <class ServerRPC, class RPCHandler>
 class [[nodiscard]] RPCHandlerSender : public detail::SenderOf<void()>
 {
   private:
-    using Service = detail::GetServerRPCServiceT<ServerRPC>;
+    using Service = detail::ServerRPCServiceT<ServerRPC>;
 
   public:
     RPCHandlerSender(agrpc::GrpcContext& grpc_context, Service& service, RPCHandler&& rpc_handler)
@@ -155,7 +155,7 @@ void create_and_start_rpc_handler_operation(
 template <class ServerRPC, class RPCHandler, class StopToken, class Allocator>
 struct RPCHandlerOperation
 {
-    using Service = detail::GetServerRPCServiceT<ServerRPC>;
+    using Service = detail::ServerRPCServiceT<ServerRPC>;
     using Traits = typename ServerRPC::Traits;
     using Starter = detail::ServerRPCStarterT<ServerRPC>;
     using RPCHandlerInvokeResult = detail::RPCHandlerInvokeResultT<Starter&, RPCHandler&, ServerRPC&>;
@@ -263,9 +263,7 @@ struct RPCHandlerOperation
                  detail::InplaceWithFunction{},
                  [&]
                  {
-                     return initial_request()
-                         .start(rpc_, operation.service(), agrpc::use_sender)
-                         .connect(StartReceiver{*this});
+                     return starter().start(rpc_, operation.service(), agrpc::use_sender).connect(StartReceiver{*this});
                  })
     {
         base().increment_ref_count();
@@ -299,7 +297,7 @@ struct RPCHandlerOperation
                 detail::InplaceWithFunction{},
                 [&]
                 {
-                    return exec::connect(initial_request().invoke(rpc_handler(), rpc_), FinishReceiver{*this});
+                    return exec::connect(starter().invoke(rpc_handler(), rpc_), FinishReceiver{*this});
                 });
             return {};
         }
@@ -326,7 +324,7 @@ struct RPCHandlerOperation
 
     auto& rpc_handler() noexcept { return base().rpc_handler(); }
 
-    auto& initial_request() noexcept { return impl1_.second(); }
+    auto& starter() noexcept { return impl1_.second(); }
 
     auto& operation_state() noexcept { return impl2_.first(); }
 
diff --git a/src/agrpc/detail/server_rpc_context_base.hpp b/src/agrpc/detail/server_rpc_context_base.hpp
index 4d54752d..8d8e9a01 100644
--- a/src/agrpc/detail/server_rpc_context_base.hpp
+++ b/src/agrpc/detail/server_rpc_context_base.hpp
@@ -128,7 +128,7 @@ struct ServerRPCContextBaseAccess
 };
 
 template <class ServerRPC>
-using GetServerRPCServiceT = decltype(detail::ServerRPCContextBaseAccess::service(std::declval<ServerRPC&>()));
+using ServerRPCServiceT = decltype(detail::ServerRPCContextBaseAccess::service(std::declval<ServerRPC&>()));
 }
 
 AGRPC_NAMESPACE_END
diff --git a/src/agrpc/detail/rpc_request.hpp b/src/agrpc/detail/server_rpc_starter.hpp
similarity index 56%
rename from src/agrpc/detail/rpc_request.hpp
rename to src/agrpc/detail/server_rpc_starter.hpp
index 290ff08f..8ff721fd 100644
--- a/src/agrpc/detail/rpc_request.hpp
+++ b/src/agrpc/detail/server_rpc_starter.hpp
@@ -12,11 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef AGRPC_DETAIL_RPC_REQUEST_HPP
-#define AGRPC_DETAIL_RPC_REQUEST_HPP
+#ifndef AGRPC_DETAIL_SERVER_RPC_STARTER_HPP
+#define AGRPC_DETAIL_SERVER_RPC_STARTER_HPP
 
-#include <agrpc/detail/start_server_rpc.hpp>
 #include <agrpc/rpc_type.hpp>
+#include <agrpc/server_rpc.hpp>
 
 #include <agrpc/detail/config.hpp>
 
@@ -32,10 +32,15 @@ constexpr bool has_initial_request(agrpc::ServerRPCType type) noexcept
 template <class Request, bool HasInitialRequest>
 struct ServerRPCStarter
 {
-    template <class RPC, class Service, class CompletionToken>
-    auto start(RPC& rpc, Service& service, CompletionToken&& token)
+    template <auto RequestRPC, class TraitsT, class Executor, class Service, class CompletionToken>
+    auto start(agrpc::ServerRPC<RequestRPC, TraitsT, Executor>& rpc, Service& service, CompletionToken&& token)
     {
-        return detail::start(rpc, service, request_, static_cast<CompletionToken&&>(token));
+        using Responder = std::remove_reference_t<decltype(ServerRPCContextBaseAccess::responder(rpc))>;
+        return detail::async_initiate_sender_implementation(
+            RPCExecutorBaseAccess::grpc_context(rpc),
+            detail::ServerRequestSenderInitiation<RequestRPC, TraitsT::NOTIFY_WHEN_DONE>{service, request_},
+            detail::ServerRequestSenderImplementation<Responder, TraitsT::NOTIFY_WHEN_DONE>{rpc},
+            static_cast<CompletionToken&&>(token));
     }
 
     template <class Handler, class RPC, class... Args>
@@ -50,10 +55,15 @@ struct ServerRPCStarter
 template <class Request>
 struct ServerRPCStarter<Request, false>
 {
-    template <class RPC, class Service, class CompletionToken>
-    auto start(RPC& rpc, Service& service, CompletionToken&& token)
+    template <auto RequestRPC, class TraitsT, class Executor, class Service, class CompletionToken>
+    auto start(agrpc::ServerRPC<RequestRPC, TraitsT, Executor>& rpc, Service& service, CompletionToken&& token)
     {
-        return detail::start(rpc, service, static_cast<CompletionToken&&>(token));
+        using Responder = std::remove_reference_t<decltype(ServerRPCContextBaseAccess::responder(rpc))>;
+        return detail::async_initiate_sender_implementation(
+            RPCExecutorBaseAccess::grpc_context(rpc),
+            detail::ServerRequestSenderInitiation<RequestRPC, TraitsT::NOTIFY_WHEN_DONE>{service},
+            detail::ServerRequestSenderImplementation<Responder, TraitsT::NOTIFY_WHEN_DONE>{rpc},
+            static_cast<CompletionToken&&>(token));
     }
 
     template <class Handler, class RPC, class... Args>
@@ -74,4 +84,4 @@ using RPCHandlerInvokeResultT =
 
 AGRPC_NAMESPACE_END
 
-#endif  // AGRPC_DETAIL_RPC_REQUEST_HPP
+#endif  // AGRPC_DETAIL_SERVER_RPC_STARTER_HPP
diff --git a/src/agrpc/detail/server_rpc_with_request.hpp b/src/agrpc/detail/server_rpc_with_request.hpp
index 3e0470a6..94b7a0ca 100644
--- a/src/agrpc/detail/server_rpc_with_request.hpp
+++ b/src/agrpc/detail/server_rpc_with_request.hpp
@@ -15,8 +15,8 @@
 #ifndef AGRPC_DETAIL_SERVER_RPC_WITH_REQUEST_HPP
 #define AGRPC_DETAIL_SERVER_RPC_WITH_REQUEST_HPP
 
-#include <agrpc/detail/rpc_request.hpp>
 #include <agrpc/detail/server_rpc_context_base.hpp>
+#include <agrpc/detail/server_rpc_starter.hpp>
 
 AGRPC_NAMESPACE_BEGIN()
 
diff --git a/src/agrpc/detail/start_server_rpc.hpp b/src/agrpc/detail/start_server_rpc.hpp
deleted file mode 100644
index d4aaeec9..00000000
--- a/src/agrpc/detail/start_server_rpc.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-// 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
-//
-//     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_START_SERVER_RPC_HPP
-#define AGRPC_DETAIL_START_SERVER_RPC_HPP
-
-#include <agrpc/detail/forward.hpp>
-#include <agrpc/detail/rpc_type.hpp>
-#include <agrpc/server_rpc.hpp>
-
-#include <agrpc/detail/config.hpp>
-
-AGRPC_NAMESPACE_BEGIN()
-
-namespace detail
-{
-template <auto RequestRPC, class TraitsT, class Executor, class Service,
-          class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-auto start(agrpc::ServerRPC<RequestRPC, TraitsT, Executor>& rpc, Service& service,
-           typename agrpc::ServerRPC<RequestRPC, TraitsT, Executor>::Request& request,
-           CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
-{
-    using Responder = std::remove_reference_t<decltype(ServerRPCContextBaseAccess::responder(rpc))>;
-    return detail::async_initiate_sender_implementation(
-        RPCExecutorBaseAccess::grpc_context(rpc),
-        detail::ServerRequestSenderInitiation<RequestRPC, TraitsT::NOTIFY_WHEN_DONE>{service, request},
-        detail::ServerRequestSenderImplementation<Responder, TraitsT::NOTIFY_WHEN_DONE>{rpc},
-        static_cast<CompletionToken&&>(token));
-}
-
-template <auto RequestRPC, class TraitsT, class Executor, class Service,
-          class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-auto start(agrpc::ServerRPC<RequestRPC, TraitsT, Executor>& rpc, Service& service,
-           CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
-{
-    using Responder = std::remove_reference_t<decltype(ServerRPCContextBaseAccess::responder(rpc))>;
-    return detail::async_initiate_sender_implementation(
-        RPCExecutorBaseAccess::grpc_context(rpc),
-        detail::ServerRequestSenderInitiation<RequestRPC, TraitsT::NOTIFY_WHEN_DONE>{service},
-        detail::ServerRequestSenderImplementation<Responder, TraitsT::NOTIFY_WHEN_DONE>{rpc},
-        static_cast<CompletionToken&&>(token));
-}
-
-template <class TraitsT, class Executor, class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-auto start(agrpc::ServerRPC<agrpc::ServerRPCType::GENERIC, TraitsT, Executor>& rpc, grpc::AsyncGenericService& service,
-           CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
-{
-    return detail::async_initiate_sender_implementation(
-        RPCExecutorBaseAccess::grpc_context(rpc),
-        detail::ServerRequestSenderInitiation<agrpc::ServerRPCType::GENERIC, TraitsT::NOTIFY_WHEN_DONE>{service},
-        detail::ServerRequestSenderImplementation<grpc::GenericServerAsyncReaderWriter, TraitsT::NOTIFY_WHEN_DONE>{rpc},
-        static_cast<CompletionToken&&>(token));
-}
-}
-
-AGRPC_NAMESPACE_END
-
-#endif  // AGRPC_DETAIL_START_SERVER_RPC_HPP
diff --git a/src/agrpc/read.hpp b/src/agrpc/read.hpp
index af2e73c6..d93fb252 100644
--- a/src/agrpc/read.hpp
+++ b/src/agrpc/read.hpp
@@ -40,7 +40,7 @@ struct ReadFn
               class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
     decltype(auto) operator()(agrpc::ServerRPC<RequestRPC, Traits, Executor>& rpc,
                               typename agrpc::ServerRPC<RequestRPC, Traits, Executor>::Request& req,
-                              CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{}) const
+                              CompletionToken&& token = CompletionToken{}) const
         noexcept(noexcept(rpc.read(req, static_cast<CompletionToken&&>(token))))
     {
         return rpc.read(req, static_cast<CompletionToken&&>(token));
@@ -56,7 +56,7 @@ struct ReadFn
     template <auto PrepareAsync, class Executor, class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
     decltype(auto) operator()(agrpc::ClientRPC<PrepareAsync, Executor>& rpc,
                               typename agrpc::ClientRPC<PrepareAsync, Executor>::Response& response,
-                              CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{}) const
+                              CompletionToken&& token = CompletionToken{}) const
         noexcept(noexcept(rpc.read(response, static_cast<CompletionToken&&>(token))))
     {
         return rpc.read(response, static_cast<CompletionToken&&>(token));
diff --git a/src/agrpc/register_awaitable_rpc_handler.hpp b/src/agrpc/register_awaitable_rpc_handler.hpp
index 5718fc0b..088c82e1 100644
--- a/src/agrpc/register_awaitable_rpc_handler.hpp
+++ b/src/agrpc/register_awaitable_rpc_handler.hpp
@@ -56,10 +56,11 @@ AGRPC_NAMESPACE_BEGIN()
  *
  * @since 2.7.0
  */
-template <class ServerRPC, class RPCHandler, class CompletionToken>
+template <class ServerRPC, class RPCHandler,
+          class CompletionToken = detail::DefaultCompletionTokenT<typename ServerRPC::executor_type>>
 auto register_awaitable_rpc_handler(const typename ServerRPC::executor_type& executor,
-                                    detail::GetServerRPCServiceT<ServerRPC>& service, RPCHandler rpc_handler,
-                                    CompletionToken&& token)
+                                    detail::ServerRPCServiceT<ServerRPC>& service, RPCHandler rpc_handler,
+                                    CompletionToken&& token = CompletionToken{})
 {
     return asio::async_initiate<CompletionToken, void(std::exception_ptr)>(
         detail::RegisterAwaitableRPCHandlerInitiator<ServerRPC>{service}, token, executor,
@@ -72,7 +73,7 @@ auto register_awaitable_rpc_handler(const typename ServerRPC::executor_type& exe
  * @since 2.7.0
  */
 template <class ServerRPC, class RPCHandler, class CompletionToken>
-auto register_awaitable_rpc_handler(agrpc::GrpcContext& grpc_context, detail::GetServerRPCServiceT<ServerRPC>& service,
+auto register_awaitable_rpc_handler(agrpc::GrpcContext& grpc_context, detail::ServerRPCServiceT<ServerRPC>& service,
                                     RPCHandler&& rpc_handler, CompletionToken&& token)
 {
     return agrpc::register_awaitable_rpc_handler<ServerRPC>(grpc_context.get_executor(), service,
diff --git a/src/agrpc/register_callback_rpc_handler.hpp b/src/agrpc/register_callback_rpc_handler.hpp
index 88c8661b..a8e01035 100644
--- a/src/agrpc/register_callback_rpc_handler.hpp
+++ b/src/agrpc/register_callback_rpc_handler.hpp
@@ -48,10 +48,11 @@ AGRPC_NAMESPACE_BEGIN()
  *
  * @since 2.8.0
  */
-template <class ServerRPC, class RPCHandler, class CompletionToken>
+template <class ServerRPC, class RPCHandler,
+          class CompletionToken = detail::DefaultCompletionTokenT<typename ServerRPC::executor_type>>
 auto register_callback_rpc_handler(const typename ServerRPC::executor_type& executor,
-                                   detail::GetServerRPCServiceT<ServerRPC>& service, RPCHandler rpc_handler,
-                                   CompletionToken&& token)
+                                   detail::ServerRPCServiceT<ServerRPC>& service, RPCHandler rpc_handler,
+                                   CompletionToken&& token = CompletionToken{})
 {
     return asio::async_initiate<CompletionToken, void(std::exception_ptr)>(
         detail::RegisterCallbackRPCHandlerInitiator<ServerRPC>{service}, token, executor,
@@ -64,7 +65,7 @@ auto register_callback_rpc_handler(const typename ServerRPC::executor_type& exec
  * @since 2.8.0
  */
 template <class ServerRPC, class RPCHandler, class CompletionToken>
-auto register_callback_rpc_handler(agrpc::GrpcContext& grpc_context, detail::GetServerRPCServiceT<ServerRPC>& service,
+auto register_callback_rpc_handler(agrpc::GrpcContext& grpc_context, detail::ServerRPCServiceT<ServerRPC>& service,
                                    RPCHandler&& rpc_handler, CompletionToken&& token)
 {
     return agrpc::register_callback_rpc_handler<ServerRPC>(grpc_context.get_executor(), service,
diff --git a/src/agrpc/register_sender_rpc_handler.hpp b/src/agrpc/register_sender_rpc_handler.hpp
index 5717fa08..d5ae65ce 100644
--- a/src/agrpc/register_sender_rpc_handler.hpp
+++ b/src/agrpc/register_sender_rpc_handler.hpp
@@ -45,7 +45,7 @@ AGRPC_NAMESPACE_BEGIN()
  */
 template <class ServerRPC, class RPCHandler>
 [[nodiscard]] detail::RPCHandlerSender<ServerRPC, RPCHandler> register_sender_rpc_handler(
-    agrpc::GrpcContext& grpc_context, detail::GetServerRPCServiceT<ServerRPC>& service, RPCHandler rpc_handler)
+    agrpc::GrpcContext& grpc_context, detail::ServerRPCServiceT<ServerRPC>& service, RPCHandler rpc_handler)
 {
     using Starter = detail::ServerRPCStarterT<ServerRPC>;
     using RPCHandlerInvokeResult = detail::RPCHandlerInvokeResultT<Starter&, RPCHandler&, ServerRPC&>;
diff --git a/src/agrpc/register_yield_rpc_handler.hpp b/src/agrpc/register_yield_rpc_handler.hpp
index b746ea8d..5bfaf10f 100644
--- a/src/agrpc/register_yield_rpc_handler.hpp
+++ b/src/agrpc/register_yield_rpc_handler.hpp
@@ -50,10 +50,11 @@ AGRPC_NAMESPACE_BEGIN()
  *
  * @since 2.7.0
  */
-template <class ServerRPC, class RPCHandler, class CompletionToken>
+template <class ServerRPC, class RPCHandler,
+          class CompletionToken = detail::DefaultCompletionTokenT<typename ServerRPC::executor_type>>
 auto register_yield_rpc_handler(const typename ServerRPC::executor_type& executor,
-                                detail::GetServerRPCServiceT<ServerRPC>& service, RPCHandler rpc_handler,
-                                CompletionToken&& token)
+                                detail::ServerRPCServiceT<ServerRPC>& service, RPCHandler rpc_handler,
+                                CompletionToken&& token = CompletionToken{})
 {
     return asio::async_initiate<CompletionToken, void(std::exception_ptr)>(
         detail::RegisterYieldRPCHandlerInitiator<ServerRPC>{service}, token, executor,
@@ -66,7 +67,7 @@ auto register_yield_rpc_handler(const typename ServerRPC::executor_type& executo
  * @since 2.7.0
  */
 template <class ServerRPC, class RPCHandler, class CompletionToken>
-auto register_yield_rpc_handler(agrpc::GrpcContext& grpc_context, detail::GetServerRPCServiceT<ServerRPC>& service,
+auto register_yield_rpc_handler(agrpc::GrpcContext& grpc_context, detail::ServerRPCServiceT<ServerRPC>& service,
                                 RPCHandler&& rpc_handler, CompletionToken&& token)
 {
     return agrpc::register_yield_rpc_handler<ServerRPC>(grpc_context.get_executor(), service,
diff --git a/src/agrpc/server_rpc.hpp b/src/agrpc/server_rpc.hpp
index 7fef79ff..fc012ed7 100644
--- a/src/agrpc/server_rpc.hpp
+++ b/src/agrpc/server_rpc.hpp
@@ -163,8 +163,7 @@ class ServerRPC<RequestUnary, TraitsT, Executor>
      * channel, etc).
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto finish(const ResponseT& response, const grpc::Status& status,
-                CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+    auto finish(const ResponseT& response, const grpc::Status& status, CompletionToken&& token = CompletionToken{})
     {
         return detail::async_initiate_sender_implementation(
             this->grpc_context(), detail::ServerFinishWithMessageInitation<Response>{response, status},
@@ -194,8 +193,7 @@ class ServerRPC<RequestUnary, TraitsT, Executor>
      * channel, etc).
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto finish_with_error(const grpc::Status& status,
-                           CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+    auto finish_with_error(const grpc::Status& status, CompletionToken&& token = CompletionToken{})
     {
         return detail::async_initiate_sender_implementation(
             this->grpc_context(), detail::ServerFinishWithErrorSenderInitation{status},
@@ -335,7 +333,7 @@ class ServerRPC<RequestClientStreaming, TraitsT, Executor>
      * failed (or been cancelled).
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto read(RequestT& req, CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+    auto read(RequestT& req, CompletionToken&& token = CompletionToken{})
     {
         return detail::async_initiate_sender_implementation(
             this->grpc_context(), detail::ServerReadSenderInitiation<Responder>{*this, req},
@@ -368,8 +366,7 @@ class ServerRPC<RequestClientStreaming, TraitsT, Executor>
      * channel, etc).
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto finish(const ResponseT& response, const grpc::Status& status,
-                CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+    auto finish(const ResponseT& response, const grpc::Status& status, CompletionToken&& token = CompletionToken{})
     {
         return detail::async_initiate_sender_implementation(
             this->grpc_context(), detail::ServerFinishWithMessageInitation<Response>{response, status},
@@ -398,8 +395,7 @@ class ServerRPC<RequestClientStreaming, TraitsT, Executor>
      * channel, etc).
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto finish_with_error(const grpc::Status& status,
-                           CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+    auto finish_with_error(const grpc::Status& status, CompletionToken&& token = CompletionToken{})
     {
         return detail::async_initiate_sender_implementation(
             this->grpc_context(), detail::ServerFinishWithErrorSenderInitation{status},
@@ -541,8 +537,7 @@ class ServerRPC<RequestServerStreaming, TraitsT, Executor>
      * channel, etc).
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto write(const ResponseT& response, grpc::WriteOptions options,
-               CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+    auto write(const ResponseT& response, grpc::WriteOptions options, CompletionToken&& token = CompletionToken{})
     {
         return detail::async_initiate_sender_implementation(
             this->grpc_context(), detail::ServerWriteSenderInitiation<Responder>{*this, response, options},
@@ -553,7 +548,7 @@ class ServerRPC<RequestServerStreaming, TraitsT, Executor>
      * @brief Send a message to the client (default WriteOptions)
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto write(const ResponseT& response, CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+    auto write(const ResponseT& response, CompletionToken&& token = CompletionToken{})
     {
         return write(response, {}, static_cast<CompletionToken&&>(token));
     }
@@ -585,7 +580,7 @@ class ServerRPC<RequestServerStreaming, TraitsT, Executor>
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
     auto write_and_finish(const ResponseT& response, grpc::WriteOptions options, const grpc::Status& status,
-                          CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+                          CompletionToken&& token = CompletionToken{})
     {
         return detail::async_initiate_sender_implementation(
             this->grpc_context(), detail::ServerWriteAndFinishSenderInitation<Response>{response, status, options},
@@ -597,7 +592,7 @@ class ServerRPC<RequestServerStreaming, TraitsT, Executor>
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
     auto write_and_finish(const ResponseT& response, const grpc::Status& status,
-                          CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+                          CompletionToken&& token = CompletionToken{})
     {
         return write_and_finish(response, {}, status,
                                 static_cast<CompletionToken&&>(static_cast<CompletionToken&&>(token)));
@@ -622,7 +617,7 @@ class ServerRPC<RequestServerStreaming, TraitsT, Executor>
      * channel, etc).
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto finish(const grpc::Status& status, CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+    auto finish(const grpc::Status& status, CompletionToken&& token = CompletionToken{})
     {
         return detail::async_initiate_sender_implementation(
             this->grpc_context(), detail::ServerFinishSenderInitation{status},
@@ -676,7 +671,7 @@ class ServerRPCBidiStreamingBase<ResponderT<ResponseT, RequestT>, TraitsT, Execu
      * messages, either because the other side has called WritesDone() or the stream has failed (or been cancelled).
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto read(RequestT& req, CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+    auto read(RequestT& req, CompletionToken&& token = CompletionToken{})
     {
         return detail::async_initiate_sender_implementation(
             this->grpc_context(), detail::ServerReadSenderInitiation<Responder>{*this, req},
@@ -698,8 +693,7 @@ class ServerRPCBidiStreamingBase<ResponderT<ResponseT, RequestT>, TraitsT, Execu
      * channel, etc).
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto write(const ResponseT& response, grpc::WriteOptions options,
-               CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+    auto write(const ResponseT& response, grpc::WriteOptions options, CompletionToken&& token = CompletionToken{})
     {
         return detail::async_initiate_sender_implementation(
             this->grpc_context(), detail::ServerWriteSenderInitiation<Responder>{*this, response, options},
@@ -710,7 +704,7 @@ class ServerRPCBidiStreamingBase<ResponderT<ResponseT, RequestT>, TraitsT, Execu
      * @brief Send a message to the client (default WriteOptions)
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto write(const ResponseT& response, CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+    auto write(const ResponseT& response, CompletionToken&& token = CompletionToken{})
     {
         return write(response, {}, static_cast<CompletionToken&&>(token));
     }
@@ -742,7 +736,7 @@ class ServerRPCBidiStreamingBase<ResponderT<ResponseT, RequestT>, TraitsT, Execu
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
     auto write_and_finish(const ResponseT& response, grpc::WriteOptions options, const grpc::Status& status,
-                          CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+                          CompletionToken&& token = CompletionToken{})
     {
         return detail::async_initiate_sender_implementation(
             this->grpc_context(), detail::ServerWriteAndFinishSenderInitation<Response>{response, status, options},
@@ -754,7 +748,7 @@ class ServerRPCBidiStreamingBase<ResponderT<ResponseT, RequestT>, TraitsT, Execu
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
     auto write_and_finish(const ResponseT& response, const grpc::Status& status,
-                          CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+                          CompletionToken&& token = CompletionToken{})
     {
         return write_and_finish(response, {}, status, static_cast<CompletionToken&&>(token));
     }
@@ -786,7 +780,7 @@ class ServerRPCBidiStreamingBase<ResponderT<ResponseT, RequestT>, TraitsT, Execu
      * channel, etc).
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto finish(const grpc::Status& status, CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+    auto finish(const grpc::Status& status, CompletionToken&& token = CompletionToken{})
     {
         return detail::async_initiate_sender_implementation(
             this->grpc_context(), detail::ServerFinishSenderInitation{status},
diff --git a/src/agrpc/waiter.hpp b/src/agrpc/waiter.hpp
index 37c5977d..e99062f7 100644
--- a/src/agrpc/waiter.hpp
+++ b/src/agrpc/waiter.hpp
@@ -144,7 +144,7 @@ class Waiter
      * All. Upon cancellation, the initiated operation continues to run.
      */
     template <class CompletionToken = detail::DefaultCompletionTokenT<Executor>>
-    auto wait(CompletionToken&& token = detail::DefaultCompletionTokenT<Executor>{})
+    auto wait(CompletionToken&& token = CompletionToken{})
     {
         return wait_impl(static_cast<CompletionToken&&>(token));
     }