diff --git a/aether/access_points/wifi_access_point.cpp b/aether/access_points/wifi_access_point.cpp
index dc3f9cd9..af98e6aa 100644
--- a/aether/access_points/wifi_access_point.cpp
+++ b/aether/access_points/wifi_access_point.cpp
@@ -118,7 +118,7 @@ ActionPtr<WifiConnectAction> WifiAccessPoint::Connect() {
     assert(driver.has_value());
 
     connect_action_ = ActionPtr<WifiConnectAction>{
-        *aether_.Load().as<Aether>(), **driver, wifi_ap_, psp_, base_station_};
+        ActionContext{*aether_.Load().as<Aether>()}, **driver, wifi_ap_, psp_, base_station_};
     connect_sub_ = connect_action_->FinishedEvent().Subscribe(
         [this]() { connect_action_.reset(); });
   }
diff --git a/aether/actions/action_ptr.h b/aether/actions/action_ptr.h
index 7440f437..5d37d1c9 100644
--- a/aether/actions/action_ptr.h
+++ b/aether/actions/action_ptr.h
@@ -22,6 +22,7 @@
 #include <type_traits>
 
 #include "aether/common.h"
+#include "aether/ae_context.h"
 #include "aether/actions/action_context.h"
 
 namespace ae {
@@ -50,6 +51,12 @@ class ActionPtr {
     action_context.get_registry().PushBack(ptr_);
   }
 
+  template <typename... TArgs>
+  explicit ActionPtr(AeContext ae_context, TArgs&&... args)
+      : ptr_{std::make_shared<TAction>(ae_context,
+                                       std::forward<TArgs>(args)...)} {
+  }
+
   template <typename UAction, AE_REQUIRERS((std::is_base_of<TAction, UAction>))>
   ActionPtr(ActionPtr<UAction> const& other) : ptr_(other.ptr_) {}
 
diff --git a/aether/ae_actions/check_access_for_send_message.cpp b/aether/ae_actions/check_access_for_send_message.cpp
index bfaf3174..ec81dfac 100644
--- a/aether/ae_actions/check_access_for_send_message.cpp
+++ b/aether/ae_actions/check_access_for_send_message.cpp
@@ -30,19 +30,17 @@ CheckAccessForSendMessage::CheckAccessForSendMessage(
           action_context,
           AuthApiRequest{[this](ApiContext<AuthorizedApi>& auth_api, auto*,
                                 auto* request) {
-            auto check_promise =
-                auth_api->check_access_for_send_message(destination_);
             wait_check_sub_ =
-                check_promise->StatusEvent().Subscribe(ActionHandler{
-                    OnResult{[&]() {
-                      ResponseReceived();
-                      request->Succeeded();
-                    }},
-                    OnError{[&]() {
-                      ErrorReceived();
-                      request->Failed();
-                    }},
-                });
+                auth_api->check_access_for_send_message(destination_)
+                    .Subscribe([&](auto const& res) {
+                      if (res) {
+                        ResponseReceived();
+                        request->Succeeded();
+                      } else {
+                        ErrorReceived();
+                        request->Failed();
+                      }
+                    });
           }},
           cloud_connection,
           request_policy,
diff --git a/aether/ae_actions/ping.cpp b/aether/ae_actions/ping.cpp
index 7c4ef6d2..e8832c91 100644
--- a/aether/ae_actions/ping.cpp
+++ b/aether/ae_actions/ping.cpp
@@ -71,7 +71,7 @@ void Ping::SendPing() {
 
   auto write_action = client_server_connection_->AuthorizedApiCall(
       SubApi{[this](ApiContext<AuthorizedApi>& auth_api) {
-        auto pong_promise = auth_api->ping(static_cast<std::uint64_t>(
+        auto& pong_promise = auth_api->ping(static_cast<std::uint64_t>(
             std::chrono::duration_cast<std::chrono::milliseconds>(
                 ping_interval_)
                 .count()));
@@ -85,11 +85,12 @@ void Ping::SendPing() {
         ping_requests_.push(PingRequest{
             current_time,
             current_time + expected_ping_time,
-            pong_promise->request_id(),
+            pong_promise.request_id(),
         });
         // Wait for response
-        wait_responses_.Push(pong_promise->StatusEvent().Subscribe(OnResult{
-            [&](auto const& promise) { PingResponse(promise.request_id()); }}));
+        wait_responses_.Push(
+            pong_promise.Subscribe([&, req_id{pong_promise.request_id()}](
+                                       auto&&) { PingResponse(req_id); }));
       }});
 
   write_subscription_ = write_action->StatusEvent().Subscribe(OnError{[this]() {
diff --git a/aether/ae_actions/select_client.cpp b/aether/ae_actions/select_client.cpp
index 591adcd3..3c6fae60 100644
--- a/aether/ae_actions/select_client.cpp
+++ b/aether/ae_actions/select_client.cpp
@@ -37,20 +37,21 @@ SelectClientAction::SelectClientAction(ActionContext action_context,
 #if AE_SUPPORT_REGISTRATION  // only if registration is supported
 SelectClientAction::SelectClientAction(ActionContext action_context,
                                        Aether& aether,
-                                       ActionPtr<Registration> registration,
+                                       Registration& registration,
                                        std::string client_id)
     : Action{action_context},
       state_{State::kWaitRegistration},
-      client_id_{std::move(client_id)},
-      registration_{std::move(registration)} {
+      client_id_{std::move(client_id)} {
   AE_TELED_DEBUG("Waiting for client registration");
-  registration_sub_ = registration_->StatusEvent().Subscribe(ActionHandler{
-      OnResult{[this, aeth{&aether}](auto& action) {
-        client_ = aeth->CreateClient(action.client_config(), client_id_);
-        state_ = State::kClientRegistered;
-      }},
-      OnError{[this]() { state_ = State::kClientRegistrationError; }},
-  });
+  registration_sub_ = registration.registration().Subscribe(
+      [this, aeth{&aether}](auto const& res) {
+        if (res) {
+          client_ = aeth->CreateClient(res.value(), client_id_);
+          state_ = State::kClientRegistered;
+        } else {
+          state_ = State::kClientRegistrationError;
+        }
+      });
 
   state_.changed_event().Subscribe([this](auto) { Action::Trigger(); });
 }
diff --git a/aether/ae_actions/select_client.h b/aether/ae_actions/select_client.h
index 07138637..fb656b7c 100644
--- a/aether/ae_actions/select_client.h
+++ b/aether/ae_actions/select_client.h
@@ -51,8 +51,7 @@ class SelectClientAction final : public Action<SelectClientAction> {
    * \brief Wait for client registration or error.
    */
   SelectClientAction(ActionContext action_context, Aether& aether,
-                     ActionPtr<Registration> registration,
-                     std::string client_id);
+                     Registration& registration, std::string client_id);
 #endif
 
   /**
diff --git a/aether/ae_actions/time_sync.cpp b/aether/ae_actions/time_sync.cpp
index 15fdb0cc..ffaa148e 100644
--- a/aether/ae_actions/time_sync.cpp
+++ b/aether/ae_actions/time_sync.cpp
@@ -143,16 +143,16 @@ class TimeSyncRequest : public Action<TimeSyncRequest> {
           auto write_action =
               cc->LoginApiCall(SubApi<LoginApi>{[this](auto& api) {
                 AE_TELED_DEBUG("Make time sync request");
-                ApiPromisePtr<std::uint64_t> promise = api->get_time_utc();
-                response_sub_ = promise->StatusEvent().Subscribe(
-                    OnResult{[this, request_time{Now()}](auto& p) {
+                response_sub_ = api->get_time_utc().Subscribe(
+                    [this, request_time{Now()}](auto const& p) {
+                      assert(p.IsOk());
                       HandleResponse(
                           std::chrono::milliseconds{
                               static_cast<std::int64_t>(p.value())},
                           request_time, Now());
                       // time synced
                       state_ = State::kResult;
-                    }});
+                    });
               }});
           write_action_sub_ =
               write_action->StatusEvent().Subscribe(OnError{[this]() {
diff --git a/aether/aether.cpp b/aether/aether.cpp
index dd9dba9e..b8d628c8 100644
--- a/aether/aether.cpp
+++ b/aether/aether.cpp
@@ -125,8 +125,7 @@ ActionPtr<SelectClientAction> Aether::SelectClient(
   }
 // register new client
 #if AE_SUPPORT_REGISTRATION
-  auto registration = RegisterClient(parent_uid);
-  return MakeSelectClient(std::move(registration), client_id);
+  return MakeSelectClient(RegisterClient(client_id, parent_uid), client_id);
 #else
   return MakeSelectClient();
 #endif
@@ -180,22 +179,21 @@ ActionPtr<SelectClientAction> Aether::MakeSelectClient(
 
 #if AE_SUPPORT_REGISTRATION
 ActionPtr<SelectClientAction> Aether::MakeSelectClient(
-    ActionPtr<Registration> registration, std::string const& client_id) {
-  auto select_action = ActionPtr<SelectClientAction>{
-      *action_processor, *this, std::move(registration), client_id};
+    Registration& registration, std::string const& client_id) {
+  auto select_action = ActionPtr<SelectClientAction>{*action_processor, *this,
+                                                     registration, client_id};
   select_client_actions_[client_id] = select_action;
   return select_action;
 }
 
-ActionPtr<Registration> Aether::RegisterClient(Uid parent_uid) {
+Registration& Aether::RegisterClient(std::string const& client_id,
+                                     Uid parent_uid) {
   auto reg_cloud = registration_cloud.Load();
   assert(reg_cloud && "Registration cloud not loaded");
 
-  // registration new client is long termed process
-  // after registration done, add it to clients list
-  // user also can get new client after
-  return ActionPtr<Registration>(*action_processor, *this, reg_cloud,
-                                 parent_uid);
+  auto& reg = registrations_[client_id] =
+      std::make_unique<Registration>(AeContext{*this}, reg_cloud, parent_uid);
+  return *reg;
 }
 #endif
 
diff --git a/aether/aether.h b/aether/aether.h
index abe93f1e..68704d9f 100644
--- a/aether/aether.h
+++ b/aether/aether.h
@@ -120,13 +120,14 @@ class Aether : public Obj {
   ActionPtr<SelectClientAction> MakeSelectClient(
       ObjPtr<Client> const& client) const;
 #if AE_SUPPORT_REGISTRATION
-  ActionPtr<SelectClientAction> MakeSelectClient(
-      ActionPtr<Registration> registration, std::string const& client_id);
+  ActionPtr<SelectClientAction> MakeSelectClient(Registration& registration,
+                                                 std::string const& client_id);
 
  public:
-  ActionPtr<Registration> RegisterClient(Uid parent_uid);
+  Registration& RegisterClient(std::string const& client_id, Uid parent_uid);
 
  private:
+  std::map<std::string, std::unique_ptr<Registration>> registrations_;
 #endif
 
   void MakeTimeSyncAction(ObjPtr<Client> const& client);
diff --git a/aether/api_protocol/api_method.h b/aether/api_protocol/api_method.h
index e60c94bc..6cf5f194 100644
--- a/aether/api_protocol/api_method.h
+++ b/aether/api_protocol/api_method.h
@@ -17,12 +17,11 @@
 #ifndef AETHER_API_PROTOCOL_API_METHOD_H_
 #define AETHER_API_PROTOCOL_API_METHOD_H_
 
-#include "aether/actions/action_context.h"
 #include "aether/api_protocol/api_message.h"
 #include "aether/api_protocol/api_context.h"
 #include "aether/api_protocol/api_pack_parser.h"
 #include "aether/api_protocol/protocol_context.h"
-#include "aether/api_protocol/api_promise_action.h"
+#include "aether/api_protocol/api_promise.h"
 
 namespace ae {
 class DefaultArgProc {
@@ -74,39 +73,40 @@ struct Method<MessageCode, void(Args...), ArgProc> {
  * return PromiseView<R> for waiting the result or error.
  */
 template <MessageId MessageCode, typename R, typename... Args, typename ArgProc>
-struct Method<MessageCode, ApiPromisePtr<R>(Args...), ArgProc> {
-  explicit Method(ProtocolContext& protocol_context,
-                  ActionContext action_context, ArgProc arg_proc = {})
-      : protocol_context_{&protocol_context},
-        action_context_{std::move(action_context)},
-        arg_proc_{std::move(arg_proc)} {}
+struct Method<MessageCode, ApiPromise<R>(Args...), ArgProc> {
+  explicit Method(ProtocolContext& protocol_context, ArgProc arg_proc = {})
+      : protocol_context_{&protocol_context}, arg_proc_{std::move(arg_proc)} {}
 
-  ApiPromisePtr<R> operator()(Args... args) {
+  ApiPromise<R>& operator()(Args... args) {
     auto request_id = RequestId::GenRequestId();
     auto* packet_stack = protocol_context_->packet_stack();
     assert(packet_stack);
     packet_stack->Push(*this,
                        arg_proc_(request_id, std::forward<Args>(args)...));
-
-    auto promise_ptr = ApiPromisePtr<R>{action_context_, request_id};
+    api_promise_.emplace(request_id);
 
     if constexpr (!std::is_same_v<void, R>) {
-      protocol_context_->AddSendResultCallback(
-          request_id,
-          [p_ptr{promise_ptr}, context{protocol_context_}]() mutable {
-            p_ptr->SetValue(context->parser()->template Extract<R>());
-          });
+      protocol_context_->AddSendResultCallback(request_id, [this]() {
+        assert(api_promise_);
+        api_promise_->SetValue(
+            protocol_context_->parser()->template Extract<R>());
+        api_promise_.reset();
+      });
     } else {
-      protocol_context_->AddSendResultCallback(
-          request_id, [p_ptr{promise_ptr}]() mutable { p_ptr->SetValue(); });
+      protocol_context_->AddSendResultCallback(request_id, [this]() {
+        assert(api_promise_);
+        api_promise_->SetValue();
+        api_promise_.reset();
+      });
     }
     protocol_context_->AddSendErrorCallback(
-        request_id, [p_ptr{promise_ptr}](auto, auto) mutable {
-          assert(p_ptr);
-          p_ptr->Reject();
+        request_id, [this](auto, std::uint32_t err) {
+          assert(api_promise_);
+          api_promise_->SetError(std::move(err));
+          api_promise_.reset();
         });
 
-    return promise_ptr;
+    return *api_promise_;
   }
 
   template <typename... Ts>
@@ -116,7 +116,7 @@ struct Method<MessageCode, ApiPromisePtr<R>(Args...), ArgProc> {
 
  private:
   ProtocolContext* protocol_context_;
-  ActionContext action_context_;
+  std::optional<ApiPromise<R>> api_promise_;
   ArgProc arg_proc_;
 };
 
diff --git a/aether/api_protocol/api_promise.h b/aether/api_protocol/api_promise.h
new file mode 100644
index 00000000..bf672302
--- /dev/null
+++ b/aether/api_protocol/api_promise.h
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2025 Aethernet Inc.
+ *
+ * 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 AETHER_API_PROTOCOL_API_PROMISE_H_
+#define AETHER_API_PROTOCOL_API_PROMISE_H_
+
+#include <cstdint>
+
+#include "aether/types/result.h"
+#include "aether/events/events.h"
+#include "aether/api_protocol/request_id.h"
+
+namespace ae {
+namespace api_promise_action_internal {
+struct Empty {};
+};  // namespace api_promise_action_internal
+
+template <typename Value, typename Error = std::uint32_t>
+class ApiPromise {
+ public:
+  using value_type = Value;
+  using error_type = Error;
+  using result_type = Result<value_type, error_type>;
+
+  constexpr explicit ApiPromise(RequestId req_id) noexcept
+      : request_id_{req_id} {}
+
+  constexpr void SetValue(value_type&& val) noexcept {
+    event_.Emit(result_type{Ok{std::move(val)}});
+  }
+
+  constexpr void SetError(error_type&& err) noexcept {
+    event_.Emit(result_type{Error{std::move(err)}});
+  }
+
+  constexpr RequestId request_id() const { return request_id_; }
+
+  template <typename Fn>
+  constexpr decltype(auto) Subscribe(Fn&& fn) noexcept {
+    return EventSubscriber{event_}.Subscribe(std::forward<Fn>(fn));
+  }
+
+ private:
+  RequestId request_id_;
+  Event<void(result_type&& res)> event_;
+};
+
+template <typename Error>
+class ApiPromise<void, Error> {
+ public:
+  using value_type = api_promise_action_internal::Empty;
+  using error_type = Error;
+  using result_type = Result<value_type, error_type>;
+
+  constexpr explicit ApiPromise(RequestId req_id) noexcept
+      : request_id_{req_id} {}
+
+  constexpr void SetValue() noexcept {
+    event_.Emit(result_type{api_promise_action_internal::Empty{}});
+  }
+
+  constexpr void SetError(error_type&& err) noexcept {
+    event_.Emit(result_type{Error{std::move(err)}});
+  }
+
+  constexpr RequestId request_id() const { return request_id_; }
+
+  template <typename Fn>
+  [[nodiscard]] constexpr decltype(auto) Subscribe(Fn&& fn) noexcept {
+    return EventSubscriber{event_}.Subscribe(std::forward<Fn>(fn));
+  }
+
+ private:
+  RequestId request_id_;
+  Event<void(result_type&& res)> event_;
+};
+
+}  // namespace ae
+#endif  // AETHER_API_PROTOCOL_API_PROMISE_H_
diff --git a/aether/api_protocol/api_promise_action.h b/aether/api_protocol/api_promise_action.h
deleted file mode 100644
index fafcd0ef..00000000
--- a/aether/api_protocol/api_promise_action.h
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * Copyright 2025 Aethernet Inc.
- *
- * 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 AETHER_API_PROTOCOL_API_PROMISE_ACTION_H_
-#define AETHER_API_PROTOCOL_API_PROMISE_ACTION_H_
-
-#include "aether/actions/action_ptr.h"
-#include "aether/actions/promise_action.h"
-#include "aether/actions/action_context.h"
-
-#include "aether/api_protocol/request_id.h"
-
-namespace ae {
-template <typename TValue>
-class ApiPromiseAction : public Action<ApiPromiseAction<TValue>> {
- public:
-  using BaseAction = Action<ApiPromiseAction<TValue>>;
-
-  ApiPromiseAction(ActionContext action_context, RequestId req_id)
-      : BaseAction{action_context},
-        promise_{action_context},
-        request_id_{req_id} {}
-
-  AE_CLASS_MOVE_ONLY(ApiPromiseAction);
-
-  UpdateStatus Update() { return promise_.Update(); }
-
-  RequestId const& request_id() const { return request_id_; }
-
-  void SetValue(TValue&& value) { promise_.SetValue(std::move(value)); }
-
-  void Reject() { promise_.Reject(); }
-
-  TValue& value() { return promise_.value(); }
-
-  TValue const& value() const { return promise_.value(); }
-
- private:
-  PromiseAction<TValue> promise_;
-  RequestId request_id_;
-};
-
-template <>
-class ApiPromiseAction<void> : public Action<ApiPromiseAction<void>> {
- public:
-  using BaseAction = Action<ApiPromiseAction<void>>;
-
-  ApiPromiseAction(ActionContext action_context, RequestId req_id)
-      : BaseAction{action_context},
-        promise_{action_context},
-        request_id_{req_id} {}
-
-  AE_CLASS_MOVE_ONLY(ApiPromiseAction);
-
-  UpdateStatus Update() { return promise_.Update(); }
-
-  RequestId const& request_id() const { return request_id_; }
-
-  void SetValue() { promise_.SetValue(); }
-
-  void Reject() { promise_.Reject(); }
-
- private:
-  PromiseAction<void> promise_;
-  RequestId request_id_;
-};
-
-template <typename T>
-using ApiPromisePtr = ActionPtr<ApiPromiseAction<T>>;
-}  // namespace ae
-#endif  // AETHER_API_PROTOCOL_API_PROMISE_ACTION_H_
diff --git a/aether/api_protocol/api_protocol.h b/aether/api_protocol/api_protocol.h
index 434b3fed..55a21e83 100644
--- a/aether/api_protocol/api_protocol.h
+++ b/aether/api_protocol/api_protocol.h
@@ -27,7 +27,7 @@
 #include "aether/api_protocol/api_class_impl.h"
 #include "aether/api_protocol/api_pack_parser.h"
 #include "aether/api_protocol/protocol_context.h"
-#include "aether/api_protocol/api_promise_action.h"
+#include "aether/api_protocol/api_promise.h"
 #include "aether/api_protocol/return_result_api.h"
 // IWYU pragma: end_exports
 
diff --git a/aether/api_protocol/make_api_call_sender.h b/aether/api_protocol/make_api_call_sender.h
new file mode 100644
index 00000000..1d8b4e1d
--- /dev/null
+++ b/aether/api_protocol/make_api_call_sender.h
@@ -0,0 +1,182 @@
+/*
+ * Copyright 2026 Aethernet Inc.
+ *
+ * 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 AETHER_API_PROTOCOL_MAKE_API_CALL_SENDER_H_
+#define AETHER_API_PROTOCOL_MAKE_API_CALL_SENDER_H_
+
+#include <utility>
+#include <cassert>
+
+#include "aether/actions/action.h"
+#include "aether/executors/executors.h"
+#include "aether/api_protocol/api_context.h"
+#include "aether/events/event_subscription.h"
+
+namespace ae {
+struct WriteFailed {};
+
+namespace make_api_call_internal {
+template <typename R>
+struct OpBase {
+  constexpr explicit OpBase(R&& r) noexcept : recv{std::move(r)} {}
+
+  virtual void Reset() noexcept {}
+  virtual bool is_reset() const noexcept { return false; }
+
+  R recv;
+
+ protected:
+  ~OpBase() = default;
+};
+
+template <typename R>
+struct Receiver {
+  using receiver_concept = ex::receiver_t;
+
+  constexpr void set_value(auto&&... v) && noexcept {
+    if (!op->is_reset()) {
+      op->Reset();
+      ex::set_value(std::move(op->recv), std::forward<decltype(v)>(v)...);
+    }
+  }
+  constexpr void set_error(auto&& e) && noexcept {
+    if (!op->is_reset()) {
+      op->Reset();
+      ex::set_error(std::move(op->recv), std::forward<decltype(e)>(e));
+    }
+  }
+  constexpr void set_stopped() && noexcept {
+    if (!op->is_reset()) {
+      op->Reset();
+      ex::set_stopped(std::move(op->recv));
+    }
+  }
+  constexpr auto get_env() noexcept {
+    assert(!op->is_reset());
+    return ex::get_env(op->recv);
+  }
+
+  OpBase<R>* op;
+};
+
+template <typename Api, typename Stream, typename Fn, ex::receiver R>
+class Operation final : public OpBase<R> {
+ public:
+  using receiver = Receiver<R>;
+
+  constexpr Operation(R&& recv, Api* api, Stream* stream, Fn&& fn) noexcept
+      : OpBase<R>{std::move(recv)},
+        api_{api},
+        stream_{stream},
+        fn_{std::move(fn)} {}
+
+  constexpr void start() noexcept {
+    // prepare api call by user's function
+    auto api_context = ApiContext<Api>{*api_};
+    // though recv_ moved inside the function, it's possible that the function
+    // does not move it inside so we keep store recv_ as a member to ensure it
+    // live enough
+    recv_.emplace(this);
+    if constexpr (std::is_invocable_v<Fn, ApiContext<Api>&, receiver&&>) {
+      std::invoke(fn_, api_context, std::move(recv_.value()));
+    } else {
+      static_assert(std::is_invocable_v<Fn, ApiContext<Api>&, receiver&>,
+                    "Fn must be invocable with ApiContext<Api>& and receiver&");
+      std::invoke(fn_, api_context, recv_.value());
+    }
+    // write the result to the stream
+    auto stream_action = stream_->Write(std::move(api_context).Pack());
+    // if stream is failed, the api call is also failed
+    sub_ = stream_action->StatusEvent().Subscribe(ActionHandler{
+        OnResult{[]() noexcept {
+          /* do nothing */
+        }},
+        OnError{[&]() noexcept {
+          Reset();
+          ex::set_error(std::move(OpBase<R>::recv), WriteFailed{});
+        }},
+        OnStop{[&]() noexcept {
+          Reset();
+          ex::set_stopped(std::move(OpBase<R>::recv));
+        }},
+    });
+  }
+
+  void Reset() noexcept override { sub_.Reset(); }
+  bool is_reset() const noexcept override { return !!sub_; }
+
+ private:
+  Api* api_;
+  Stream* stream_;
+  Fn fn_;
+  Subscription sub_;
+  std::optional<receiver> recv_;
+};
+
+template <typename Completions, typename Api, typename Stream, typename Fn>
+class Sender {
+ public:
+  using sender_concept = ex::sender_t;
+
+  template <typename...>
+  static consteval auto get_completion_signatures() noexcept {
+    return ex::__transform_completion_signatures(
+        Completions{}, ex::__keep_completion<ex::set_value_t>{},
+        ex::__keep_completion<ex::set_error_t>{},
+        ex::__keep_completion<ex::set_stopped_t>{},
+        ex::completion_signatures<ex::set_error_t(WriteFailed)>{});
+  }
+
+  constexpr Sender(Api& api, Stream& stream, Fn&& fn) noexcept
+      : api_{&api}, stream_{&stream}, fn_{std::move(fn)} {}
+
+  constexpr auto connect(ex::receiver auto&& recv) noexcept {
+    return Operation<Api, Stream, Fn, std::decay_t<decltype(recv)>>{
+        std::forward<decltype(recv)>(recv),
+        api_,
+        stream_,
+        std::move(fn_),
+    };
+  }
+
+ private:
+  Api* api_;
+  Stream* stream_;
+  Fn fn_;
+};
+
+template <typename... Sigs>
+struct MakeApiCall {
+  template <typename Api, typename Stream, typename Fn>
+  constexpr auto operator()(Api& api, Stream& stream, Fn&& fn) const noexcept {
+    return Sender<ex::completion_signatures<Sigs...>, Api, Stream,
+                  std::decay_t<Fn>>{
+        api,
+        stream,
+        std::forward<decltype(fn)>(fn),
+    };
+  }
+};
+
+}  // namespace make_api_call_internal
+
+template <typename... Sigs>
+static constexpr inline auto make_api_call =
+    make_api_call_internal::MakeApiCall<Sigs...>{};
+
+}  // namespace ae
+
+#endif  // AETHER_API_PROTOCOL_MAKE_API_CALL_SENDER_H_
diff --git a/aether/client.cpp b/aether/client.cpp
index 7327d436..7ca66229 100644
--- a/aether/client.cpp
+++ b/aether/client.cpp
@@ -76,7 +76,7 @@ CloudServerConnections& Client::cloud_connection() {
 #if AE_TELE_ENABLED
     // also create telemetry
     telemetry_ =
-        ActionPtr<Telemetry>(*aether_.Load().as<Aether>(),
+        ActionPtr<Telemetry>(ActionContext{*aether_.Load().as<Aether>()},
                              Aether::ptr{aether_}.Load(), *cloud_connection_);
 #endif
   }
diff --git a/aether/connection_manager/client_cloud_manager.cpp b/aether/connection_manager/client_cloud_manager.cpp
index e7d7b111..8f78faff 100644
--- a/aether/connection_manager/client_cloud_manager.cpp
+++ b/aether/connection_manager/client_cloud_manager.cpp
@@ -205,7 +205,7 @@ ActionPtr<GetCloudAction> ClientCloudManager::GetCloud(Uid client_uid) {
   if (cached != cloud_cache_.end()) {
     assert(cached->second.is_valid());
     return ActionPtr<client_cloud_manager_internal::GetCloudFromCache>{
-        *aether, cached->second};
+        ActionContext{*aether}, cached->second};
   }
   // get from aethernet
 
@@ -213,7 +213,7 @@ ActionPtr<GetCloudAction> ClientCloudManager::GetCloud(Uid client_uid) {
   assert(client);
 
   return ActionPtr<client_cloud_manager_internal::GetCloudFromAether>{
-      *aether, *aether, *this, client->cloud_connection(), client_uid};
+      ActionContext{*aether}, *aether, *this, client->cloud_connection(), client_uid};
 }
 
 Cloud::ptr ClientCloudManager::RegisterCloud(Uid uid,
diff --git a/aether/executors/async_wait.h b/aether/executors/async_wait.h
index 79237941..00d0e838 100644
--- a/aether/executors/async_wait.h
+++ b/aether/executors/async_wait.h
@@ -26,6 +26,7 @@
 #include <type_traits>
 
 #include "aether/types/result.h"
+#include "aether/meta/ignore_t.h"
 #include "aether/meta/type_list.h"
 #include "aether/executors/scheduler_on_tasks.h"
 
@@ -34,6 +35,8 @@
 namespace ae::ex {
 
 namespace async_wait_internal {
+namespace {
+
 template <template <typename> typename Filter, typename T>
 struct FilterList;
 
@@ -49,32 +52,66 @@ struct FilterList<Filter, TypeList<>> {
   using type = TypeList<>;
 };
 
-template <stdexec::sender Sender, typename Env>
+template <typename T>
+struct FilterExceptionPtr {
+  static constexpr bool value =
+      std::is_same_v<std::decay_t<T>, std::exception_ptr>;
+};
+
+/**
+ * Expand value list.
+ * It may be a variant of values
+ * Values may be a tuples or single values
+ * Or it may be a single value or void
+ */
+template <typename>
+struct ExpandTuple;
+template <>
+struct ExpandTuple<TypeList<>> {
+  using type = Ignore;
+};
+template <typename T>
+struct ExpandTuple<TypeList<T>> {
+  using type = T;
+};
+template <typename... T>
+struct ExpandTuple<TypeList<T...>> {
+  using type = std::tuple<T...>;
+};
+
+template <typename>
+struct ExpandVariant;
+template <>
+struct ExpandVariant<TypeList<>> {
+  using type = Ignore;
+};
+template <typename T>
+struct ExpandVariant<TypeList<T>> {
+  using type = ExpandTuple<T>::type;
+};
+template <typename... T>
+struct ExpandVariant<TypeList<T...>> {
+  using type = TypeListToTemplate_t<
+      std::variant,
+      typename FilterList<IsIgnore,
+                          TypeList<typename ExpandTuple<T>::type...>>::type>;
+};
+}  // namespace
+
+template <stdexec::sender Sender, typename... Env>
 struct SenderTraits {
-  static constexpr auto cs = stdexec::get_completion_signatures<Sender, Env>();
+  static constexpr auto cs =
+      stdexec::get_completion_signatures<Sender, Env...>();
   using ValueList =
       stdexec::__value_types_t<decltype(cs), stdexec::__q<TypeList>,
-                               stdexec::__q<stdexec::__msingle>>;
+                               stdexec::__q<TypeList>>;
   using ErrorList =
       stdexec::__error_types_t<decltype(cs), stdexec::__q<TypeList>,
                                stdexec::__q<stdexec::__msingle>>;
 
-  static_assert((TypeListSize_v<ValueList> > 0),
-                "Value list must not be empty");
-
-  using ValueType =
-      std::conditional_t<(TypeListSize_v<ValueList> > 1),
-                         TypeListToTemplate_t<std::tuple, ValueList>,
-                         TypeAt_t<0, ValueList>>;
-
-  template <typename T>
-  struct FilterExceptionPtr {
-    static constexpr bool value =
-        std::is_same_v<std::decay_t<T>, std::exception_ptr>;
-  };
+  using ValueType = ExpandVariant<ValueList>::type;
 
-  using FilteredErrorList =
-      typename FilterList<FilterExceptionPtr, ErrorList>::type;
+  using FilteredErrorList = FilterList<FilterExceptionPtr, ErrorList>::type;
 
   using ErrorType =
       std::conditional_t<(TypeListSize_v<FilteredErrorList> > 1),
@@ -183,7 +220,7 @@ class AsyncWaiter : async_wait_internal::WaiterBase {
 
  public:
   explicit constexpr AsyncWaiter(AeContext const& context, Sender&& sender,
-                                 Callback&& cb)
+                                 Callback&& cb) noexcept
       : async_wait_internal::WaiterBase{context},
         state_{.wait_result = {}, .cb = std::move(cb), .env = {this}},
         op_{stdexec::connect(std::move(sender), Receiver{state_})} {
@@ -203,4 +240,79 @@ auto MakeAsyncWaiter(AeContext const& context, Sender&& sender,
 }
 }  // namespace ae::ex
 
+#if AE_TESTS
+
+#  include "tests/inline.h"
+
+namespace tests::async_wait_h {
+
+template <typename... Sigs>
+struct NotSender {
+  using sender_concept = stdexec::sender_t;
+
+  template <typename...>
+  static consteval auto get_completion_signatures() {
+    return stdexec::completion_signatures<Sigs...>{};
+  }
+};
+
+using namespace ae::ex::async_wait_internal;  // NOLINT
+using namespace ae;                           // NOLINT
+
+AE_TEST_INLINE(test_SenderTraits) {
+  using sender1 =
+      NotSender<stdexec::set_value_t(int), stdexec::set_error_t(int)>;
+
+  using traits1 = SenderTraits<sender1, Env>;
+
+  static_assert(std::is_same_v<TypeList<TypeList<int>>, traits1::ValueList>);
+  static_assert(std::is_same_v<int, traits1::ValueType>);
+  static_assert(std::is_same_v<int, traits1::ErrorType>);
+
+  using sender2 =
+      NotSender<stdexec::set_value_t(int, float), stdexec::set_error_t(int)>;
+  using traits2 = SenderTraits<sender2, Env>;
+  static_assert(
+      std::is_same_v<TypeList<TypeList<int, float>>, traits2::ValueList>);
+  static_assert(std::is_same_v<std::tuple<int, float>, traits2::ValueType>);
+  static_assert(std::is_same_v<int, traits2::ErrorType>);
+
+  using sender3 = NotSender<stdexec::set_value_t(), stdexec::set_error_t(int)>;
+  using traits3 = SenderTraits<sender3, Env>;
+  static_assert(std::is_same_v<TypeList<TypeList<>>, traits3::ValueList>);
+  static_assert(std::is_same_v<Ignore, traits3::ValueType>);
+  static_assert(std::is_same_v<int, traits3::ErrorType>);
+
+  using sender4 =
+      NotSender<stdexec::set_value_t(int), stdexec::set_value_t(float),
+                stdexec::set_error_t(int)>;
+  using traits4 = SenderTraits<sender4, Env>;
+  static_assert(std::is_same_v<TypeList<TypeList<int>, TypeList<float>>,
+                               traits4::ValueList>);
+  static_assert(std::is_same_v<std::variant<int, float>, traits4::ValueType>);
+  static_assert(std::is_same_v<int, traits4::ErrorType>);
+
+  using sender5 =
+      NotSender<stdexec::set_value_t(), stdexec::set_value_t(int, float),
+                stdexec::set_value_t(bool), stdexec::set_error_t(int),
+                stdexec::set_error_t(std::exception_ptr)>;
+  using traits5 = SenderTraits<sender5, Env>;
+  static_assert(
+      std::is_same_v<TypeList<TypeList<>, TypeList<int, float>, TypeList<bool>>,
+                     traits5::ValueList>);
+  static_assert(std::is_same_v<std::variant<std::tuple<int, float>, bool>,
+                               traits5::ValueType>);
+  static_assert(std::is_same_v<int, traits5::ErrorType>);
+
+  using sender6 = NotSender<stdexec::set_error_t(int),
+                            stdexec::set_error_t(std::exception_ptr)>;
+  using traits6 = SenderTraits<sender6, Env>;
+  static_assert(std::is_same_v<TypeList<>, traits6::ValueList>);
+  static_assert(std::is_same_v<Ignore, traits6::ValueType>);
+  static_assert(std::is_same_v<int, traits6::ErrorType>);
+
+  TEST_PASS();
+}
+}  // namespace tests::async_wait_h
+#endif  // AE_TESTS
 #endif  // AETHER_EXECUTORS_ASYNC_WAIT_H_
diff --git a/aether/executors/executors.h b/aether/executors/executors.h
index c18759c2..8751df3f 100644
--- a/aether/executors/executors.h
+++ b/aether/executors/executors.h
@@ -27,8 +27,9 @@ DISABLE_WARNING_POP()
 
 #include "aether/executors/for_range.h"
 #include "aether/executors/any_sender.h"
-#include "aether/executors/make_sender.h"
 #include "aether/executors/async_wait.h"
+#include "aether/executors/with_timeout.h"
+#include "aether/executors/make_sender.h"
 #include "aether/executors/scheduler_on_tasks.h"
 // IWYU pragma: end_exports
 
diff --git a/aether/executors/for_range.h b/aether/executors/for_range.h
index 882dfc6e..5425e95a 100644
--- a/aether/executors/for_range.h
+++ b/aether/executors/for_range.h
@@ -24,6 +24,7 @@
 #include "third_party/stdexec/include/stdexec/execution.hpp"
 
 #include "aether/types/iterator.h"
+#include "aether/meta/type_list.h"
 
 namespace ae::ex {
 namespace for_range_internal {
@@ -53,13 +54,17 @@ template <typename R>
 struct Receiver {
   using receiver_concept = stdexec::receiver_t;
 
-  template <typename U>
-  constexpr void set_value(U&& val) && noexcept {
-    using value_type = std::decay_t<U>;
-    if constexpr (IsContinue_v<value_type>) {
-      operation->Repeat();
+  template <typename... U>
+  constexpr void set_value(U&&... val) && noexcept {
+    if constexpr (sizeof...(val) == 1) {
+      using value_type = std::decay_t<TypeAt_t<0, TypeList<U...>>>;
+      if constexpr (IsContinue_v<value_type>) {
+        operation->Repeat();
+      } else {
+        stdexec::set_value(std::move(operation->recv), std::forward<U>(val)...);
+      }
     } else {
-      stdexec::set_value(std::move(operation->recv), std::forward<U>(val));
+      stdexec::set_value(std::move(operation->recv), std::forward<U>(val)...);
     }
   }
 
diff --git a/aether/executors/with_timeout.h b/aether/executors/with_timeout.h
new file mode 100644
index 00000000..371ca421
--- /dev/null
+++ b/aether/executors/with_timeout.h
@@ -0,0 +1,169 @@
+/*
+ * Copyright 2026 Aethernet Inc.
+ *
+ * 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 AETHER_EXECUTORS_WITH_TIMEOUT_H_
+#define AETHER_EXECUTORS_WITH_TIMEOUT_H_
+
+#include <utility>
+#include <cassert>
+
+#include "third_party/stdexec/include/stdexec/execution.hpp"
+
+#include "aether/clock.h"
+#include "aether/ae_context.h"
+
+namespace ae::ex {
+struct TimeoutError {};
+
+namespace async_timeout_internal {
+template <typename R>
+class OpBase {
+ public:
+  constexpr explicit OpBase(R&& recv) noexcept : recv{std::move(recv)} {}
+  virtual void Reset() noexcept {}
+  virtual bool is_reset() noexcept { return false; }
+
+  R recv;
+
+ protected:
+  ~OpBase() = default;
+};
+
+template <typename R>
+struct Receiver {
+  using receiver_concept = stdexec::receiver_t;
+
+  constexpr void set_value(auto&&... v) && noexcept {
+    if (!op->is_reset()) {
+      op->Reset();
+      stdexec::set_value(std::move(op->recv), std::forward<decltype(v)>(v)...);
+    }
+  }
+  constexpr void set_error(auto&& e) && noexcept {
+    if (!op->is_reset()) {
+      op->Reset();
+      stdexec::set_error(std::move(op->recv), std::forward<decltype(e)>(e));
+    }
+  }
+  constexpr void set_stopped() && noexcept {
+    if (!op->is_reset()) {
+      op->Reset();
+      stdexec::set_stopped(std::move(op->recv));
+    }
+  }
+  constexpr auto get_env() const& noexcept {
+    assert(!op->is_reset());
+    return stdexec::get_env(op->recv);
+  }
+
+  OpBase<R>* op;
+};
+
+template <stdexec::sender Child, stdexec::receiver R>
+class Operation final : OpBase<R> {
+ public:
+  using receiver = Receiver<R>;
+  using op_state = stdexec::connect_result_t<Child, receiver>;
+
+  constexpr Operation(Child&& child, AeContext ae_context, Duration duration,
+                      R&& recv)
+      : OpBase<R>{std::move(recv)},
+        child_(std::move(child)),
+        ae_context_(std::move(ae_context)),
+        duration_(std::move(duration)) {}
+
+  constexpr void start() noexcept {
+    op_.__emplace_from(stdexec::connect, std::move(child_),
+                       Receiver{.op = this});
+    ae_context_.scheduler().DelayedTask(
+        [&]() noexcept {
+          if (!is_reset()) {
+            stdexec::set_error(std::move(OpBase<R>::recv), TimeoutError{});
+            Reset();
+          }
+        },
+        duration_);
+
+    op_->start();
+  }
+
+  void Reset() noexcept override { is_reset_ = true; }
+  bool is_reset() noexcept override { return false; }
+
+ private:
+  Child child_;
+  AeContext ae_context_;
+  Duration duration_;
+  stdexec::__optional<op_state> op_;
+  bool is_reset_{false};
+};
+
+template <stdexec::sender Child>
+class Sender {
+ public:
+  using sender_concept = stdexec::sender_t;
+
+  template <typename S, typename... Env>
+  static consteval auto get_completion_signatures() {
+    constexpr auto chind_completions =
+        stdexec::get_completion_signatures<Child, Env...>();
+    return stdexec::__transform_completion_signatures(
+        chind_completions, stdexec::__keep_completion<stdexec::set_value_t>{},
+        stdexec::__keep_completion<stdexec::set_error_t>{},
+        stdexec::__keep_completion<stdexec::set_stopped_t>{},
+        // add error timeout
+        stdexec::completion_signatures<stdexec::set_error_t(TimeoutError)>{});
+  }
+
+  constexpr Sender(Child&& child, AeContext const& context,
+                   Duration duration) noexcept
+      : child_{std::move(child)}, ae_context_{context}, duration_{duration} {}
+
+  constexpr auto connect(stdexec::receiver auto&& recv) && noexcept {
+    return Operation<Child, std::decay_t<decltype(recv)>>{
+        std::move(child_),
+        std::move(ae_context_),
+        duration_,
+        std::forward<decltype(recv)>(recv),
+    };
+  }
+
+ private:
+  Child child_;
+  AeContext ae_context_;
+  Duration duration_;
+};
+
+struct WithAsyncTimeout {
+  constexpr auto operator()(stdexec::sender auto&& sender,
+                            AeContext const& context,
+                            Duration duration) const noexcept {
+    return Sender{std::forward<decltype(sender)>(sender), context, duration};
+  };
+
+  constexpr auto operator()(AeContext const& context,
+                            Duration duration) const noexcept {
+    return stdexec::__closure{*this, context, duration};
+  };
+};
+
+}  // namespace async_timeout_internal
+
+static constexpr inline auto with_timeout =
+    async_timeout_internal::WithAsyncTimeout{};
+}  // namespace ae::ex
+
+#endif  // AETHER_EXECUTORS_WITH_TIMEOUT_H_
diff --git a/aether/meta/ignore_t.h b/aether/meta/ignore_t.h
new file mode 100644
index 00000000..19c18b8a
--- /dev/null
+++ b/aether/meta/ignore_t.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2026 Aethernet Inc.
+ *
+ * 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 AETHER_META_IGNORE_T_H_
+#define AETHER_META_IGNORE_T_H_
+
+#include <type_traits>
+
+namespace ae {
+struct Ignore {
+  template <typename... Us>
+  constexpr explicit Ignore(Us&&...) noexcept {}
+};
+
+template <typename T>
+struct IsIgnore : std::false_type {};
+
+template <>
+struct IsIgnore<Ignore> : std::true_type {};
+template <typename T>
+static constexpr inline bool IsIgnore_v = IsIgnore<T>::value;
+}  // namespace ae
+
+#endif  // AETHER_META_IGNORE_T_H_
diff --git a/aether/misc/override.h b/aether/misc/override.h
new file mode 100644
index 00000000..fbf30ab8
--- /dev/null
+++ b/aether/misc/override.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2026 Aethernet Inc.
+ *
+ * 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 AETHER_MISC_OVERRIDE_H_
+#define AETHER_MISC_OVERRIDE_H_
+
+#include <utility>
+
+namespace ae {
+/**
+ * \brief Functor overridable with many other functors.
+ * Has a cumulative operator() of all Fs functors.
+ */
+template <typename... Fs>
+struct Override : Fs... {
+  explicit Override(Fs... funcs) : Fs{std::forward<Fs>(funcs)}... {}
+
+  using Fs::operator()...;
+};
+template <typename... U>
+Override(U&&...) -> Override<U...>;
+}  // namespace ae
+
+#endif  // AETHER_MISC_OVERRIDE_H_
diff --git a/aether/registration/api/global_reg_server_api.cpp b/aether/registration/api/global_reg_server_api.cpp
index 5e2cfce2..79a4859a 100644
--- a/aether/registration/api/global_reg_server_api.cpp
+++ b/aether/registration/api/global_reg_server_api.cpp
@@ -18,10 +18,9 @@
 
 #if AE_SUPPORT_REGISTRATION
 namespace ae {
-GlobalRegServerApi::GlobalRegServerApi(ProtocolContext& protocol_context,
-                                       ActionContext action_context)
+GlobalRegServerApi::GlobalRegServerApi(ProtocolContext& protocol_context)
     : ApiClass{protocol_context},
       set_master_key{protocol_context},
-      finish{protocol_context, action_context} {}
+      finish{protocol_context} {}
 }  // namespace ae
 #endif
diff --git a/aether/registration/api/global_reg_server_api.h b/aether/registration/api/global_reg_server_api.h
index a1f03d5f..718f948e 100644
--- a/aether/registration/api/global_reg_server_api.h
+++ b/aether/registration/api/global_reg_server_api.h
@@ -39,11 +39,10 @@ struct RegistrationResponse {
 
 class GlobalRegServerApi : public ApiClass {
  public:
-  GlobalRegServerApi(ProtocolContext& protocol_context,
-                     ActionContext action_context);
+  explicit GlobalRegServerApi(ProtocolContext& protocol_context);
 
   Method<03, void(Key key)> set_master_key;
-  Method<04, ApiPromisePtr<RegistrationResponse>()> finish;
+  Method<04, ApiPromise<RegistrationResponse>()> finish;
 };
 
 }  // namespace ae
diff --git a/aether/registration/api/registration_root_api.cpp b/aether/registration/api/registration_root_api.cpp
index ebe4b716..b11cd545 100644
--- a/aether/registration/api/registration_root_api.cpp
+++ b/aether/registration/api/registration_root_api.cpp
@@ -19,15 +19,13 @@
 #if AE_SUPPORT_REGISTRATION
 namespace ae {
 RegistrationRootApi::RegistrationRootApi(ProtocolContext& protocol_context,
-                                         ActionContext action_context,
                                          IEncryptProvider& root_encrypt,
                                          IEncryptProvider& global_encrypt)
     : ApiClass{protocol_context},
-      get_asymmetric_public_key{protocol_context, action_context},
+      get_asymmetric_public_key{protocol_context},
       enter{protocol_context, EnterProc{*this}},
       enc_provider_{&root_encrypt},
-      server_registration_api_{protocol_context, action_context,
-                               global_encrypt} {}
+      server_registration_api_{protocol_context, global_encrypt} {}
 
 DataBuffer RegistrationRootApi::Encrypt(DataBuffer const& data) const {
   return enc_provider_->Encrypt(data);
diff --git a/aether/registration/api/registration_root_api.h b/aether/registration/api/registration_root_api.h
index 289d5121..b541aae4 100644
--- a/aether/registration/api/registration_root_api.h
+++ b/aether/registration/api/registration_root_api.h
@@ -49,11 +49,10 @@ class RegistrationRootApi : public ApiClass {
 
  public:
   RegistrationRootApi(ProtocolContext& protocol_context,
-                      ActionContext action_context,
                       IEncryptProvider& root_encrypt,
                       IEncryptProvider& global_encrypt);
 
-  Method<03, ApiPromisePtr<SignedKey>(CryptoLib crypto_lib)>
+  Method<03, ApiPromise<SignedKey>(CryptoLib crypto_lib)>
       get_asymmetric_public_key;
   Method<04, void(CryptoLib crypto_lib, SubApi<ServerRegistrationApi> sub_api),
          EnterProc>
diff --git a/aether/registration/api/server_registration_api.cpp b/aether/registration/api/server_registration_api.cpp
index fb89b7ef..e494d47d 100644
--- a/aether/registration/api/server_registration_api.cpp
+++ b/aether/registration/api/server_registration_api.cpp
@@ -20,15 +20,14 @@
 
 namespace ae {
 ServerRegistrationApi::ServerRegistrationApi(ProtocolContext& protocol_context,
-                                             ActionContext action_context,
                                              IEncryptProvider& encrypt_provider)
     : ApiClass{protocol_context},
       registration{protocol_context, RegistrationProc{*this}},
-      request_proof_of_work_data{protocol_context, action_context},
-      resolve_servers{protocol_context, action_context},
+      request_proof_of_work_data{protocol_context},
+      resolve_servers{protocol_context},
       set_return_key{protocol_context},
       encrypt_provider_{&encrypt_provider},
-      global_reg_server_api_{protocol_context, action_context} {}
+      global_reg_server_api_{protocol_context} {}
 
 DataBuffer ServerRegistrationApi::Encrypt(DataBuffer const& data) const {
   return encrypt_provider_->Encrypt(data);
diff --git a/aether/registration/api/server_registration_api.h b/aether/registration/api/server_registration_api.h
index 0304f9d2..02e76e9c 100644
--- a/aether/registration/api/server_registration_api.h
+++ b/aether/registration/api/server_registration_api.h
@@ -70,7 +70,6 @@ class ServerRegistrationApi : public ApiClass {
 
  public:
   ServerRegistrationApi(ProtocolContext& protocol_context,
-                        ActionContext action_context,
                         IEncryptProvider& encrypt_provider);
 
   Method<3,
@@ -80,10 +79,10 @@ class ServerRegistrationApi : public ApiClass {
          RegistrationProc>
       registration;
 
-  Method<4, ApiPromisePtr<PowParams>(Uid parent_id, PowMethod pow_method)>
+  Method<4, ApiPromise<PowParams>(Uid parent_id, PowMethod pow_method)>
       request_proof_of_work_data;
 
-  Method<5, ApiPromisePtr<std::vector<ServerDescriptor>>(
+  Method<5, ApiPromise<std::vector<ServerDescriptor>>(
                 std::vector<ServerId> servers)>
       resolve_servers;
 
diff --git a/aether/registration/registration.cpp b/aether/registration/registration.cpp
index 7d9da8f6..b3ae85fd 100644
--- a/aether/registration/registration.cpp
+++ b/aether/registration/registration.cpp
@@ -23,9 +23,11 @@
 #  include "aether/aether.h"
 #  include "aether/crypto.h"
 #  include "aether/crypto/sign.h"
+#  include "aether/misc/override.h"
+#  include "aether/executors/executors.h"
 #  include "aether/api_protocol/api_context.h"
 #  include "aether/crypto/crypto_definitions.h"
-#  include "aether/stream_api/api_call_adapter.h"
+#  include "aether/api_protocol/make_api_call_sender.h"
 
 #  include "aether/registration/proof_of_work.h"
 #  include "aether/registration/registration_crypto_provider.h"
@@ -34,299 +36,229 @@
 
 namespace ae {
 
-Registration::Registration(ActionContext action_context, Aether& aether,
+Registration::Registration(AeContext const& ae_context,
                            Ptr<RegistrationCloud> const& reg_cloud,
                            Uid parent_uid)
-    : Action{action_context},
-      action_context_{action_context},
+    : ae_context_{ae_context},
       parent_uid_{std::move(parent_uid)},
-      root_crypto_provider_{std::make_unique<RegistrationCryptoProvider>()},
-      global_crypto_provider_{std::make_unique<RegistrationCryptoProvider>()},
-      client_root_api_{protocol_context_, *root_crypto_provider_->decryptor(),
-                       *global_crypto_provider_->decryptor()},
-      server_reg_root_api_{protocol_context_, action_context_,
-                           *root_crypto_provider_->encryptor(),
-                           *global_crypto_provider_->encryptor()},
-      root_server_select_stream_{aether, reg_cloud},
-      state_{State::kInitConnection},
+      root_crypto_provider_{},
+      global_crypto_provider_{},
+      client_root_api_{protocol_context_, *root_crypto_provider_.decryptor(),
+                       *global_crypto_provider_.decryptor()},
+      server_reg_root_api_{protocol_context_,
+                           *root_crypto_provider_.encryptor(),
+                           *global_crypto_provider_.encryptor()},
+      root_server_select_stream_{ae_context_, reg_cloud},
       // TODO: add configuration
       response_timeout_{std::chrono::seconds(20)},
-      sign_pk_{Crypto::ptr{aether.crypto}->signs_pk_[kDefaultSignatureMethod]} {
+      sign_pk_{Crypto::ptr{ae_context_.aether().crypto}
+                   ->signs_pk_[kDefaultSignatureMethod]} {
   AE_TELE_INFO(RegisterStarted);
 
   // parent uid must not be empty
   assert(!parent_uid_.empty());
 
-  // trigger action on state change
-  state_change_subscription_ =
-      state_.changed_event().Subscribe([this](auto) { Action::Trigger(); });
+  InitConnection();
+  Run();
 }
 
 Registration::~Registration() { AE_TELED_DEBUG("~Registration"); }
 
-UpdateStatus Registration::Update() {
-  AE_TELED_DEBUG("Registration::Update state {}", state_.get());
-
-  // TODO: add check for actual packet sending or method timeouts
-
-  if (state_.changed()) {
-    switch (state_.Acquire()) {
-      case State::kInitConnection:
-        InitConnection();
-        break;
-      case State::kRestreamConnection:
-        Restream();
-        break;
-      case State::kGetKeys:
-        GetKeys();
-        break;
-      case State::kGetPowParams:
-        RequestPowParams();
-        break;
-      case State::kMakeRegistration:
-        MakeRegistration();
-        break;
-      case State::kRequestCloudResolving:
-        ResolveCloud();
-        break;
-      case State::kRegistered:
-        return UpdateStatus::Result();
-      case State::kRegistrationFailed:
-        return UpdateStatus::Error();
-      default:
-        break;
-    }
-  }
-  if (state_.get() == State::kWaitKeys) {
-    return UpdateStatus::Delay(WaitKeys());
-  }
-
-  return {};
+Registration::RegistrationEvent::Subscriber Registration::registration() {
+  return EventSubscriber{registration_event_};
 }
-
-ClientConfig const& Registration::client_config() const {
-  return client_config_;
+Registration::FinishedEvent::Subscriber Registration::IsFinished() {
+  return EventSubscriber{finished_event_};
 }
 
 void Registration::InitConnection() {
   AE_TELED_DEBUG("Registration::InitConnection");
 
-  root_server_select_stream_.server_changed_event().Subscribe([this]() {
+  root_server_select_stream_.server_changed_event().Subscribe([]() {
     // Reinit connection and start registration from the beginning
+    // TODO: make async_waiter_ stop and start get keys again
     AE_TELED_ERROR("Server changed");
-    state_ = State::kInitConnection;
   });
 
-  root_server_select_stream_.cloud_error_event().Subscribe([this]() {
+  root_server_select_stream_.cloud_error_event().Subscribe([]() {
     AE_TELED_ERROR("Link Error, Registration failed");
-    state_ = State::kRegistrationFailed;
+    // TODO: make async_waiter_ stop with error
   });
 
   // Connect parser for out data
-  data_read_subscription_ =
-      root_server_select_stream_.out_data_event().Subscribe(
-          [this](const auto& data) {
-            auto parser = ApiParser{protocol_context_, data};
-            parser.Parse(client_root_api_);
-          });
-
-  state_ = State::kGetKeys;
-}
-
-void Registration::Restream() {
-  state_ = State::kInitConnection;
-  root_server_select_stream_.Restream();
+  root_server_select_stream_.out_data_event().Subscribe(
+      [this](auto const& data) {
+        auto parser = ApiParser{protocol_context_, data};
+        parser.Parse(client_root_api_);
+      });
 }
 
-void Registration::GetKeys() {
-  AE_TELE_INFO(RegisterGetKeys, "GetKeys");
-
-  auto api_call = ApiCallAdapter{ApiContext{server_reg_root_api_},
-                                 root_server_select_stream_};
-
-  auto get_key_promise =
-      api_call->get_asymmetric_public_key(kDefaultCryptoLibProfile);
-
-  response_sub_ = get_key_promise->StatusEvent().Subscribe(ActionHandler{
-      OnResult{[&](auto& promise) {
-        auto& signed_key = promise.value();
-        auto r = CryptoSignVerify(signed_key.sign, signed_key.key, sign_pk_);
-        if (!r) {
-          AE_TELE_ERROR(RegisterGetKeysVerificationFailed,
-                        "Sign verification failed");
-          state_ = State::kRegistrationFailed;
-          return;
-        }
-
-        server_pub_key_ = std::move(signed_key.key);
-        state_ = State::kGetPowParams;
-      }},
-      OnError{[&]() { state_ = State::kRegistrationFailed; }},
-  });
-
-  packet_write_action_ = api_call.Flush();
-
-  // on error try repeat
-  raw_transport_send_action_subscription_ =
-      packet_write_action_->StatusEvent().Subscribe(
-          OnError{[&]() { state_ = State::kRestreamConnection; }});
-  last_request_time_ = Now();
-
-  state_ = State::kWaitKeys;
-}
-
-TimePoint Registration::WaitKeys() {
-  auto current_time = Now();
-  if (last_request_time_ + response_timeout_ < current_time) {
-    AE_TELE_WARNING(RegisterWaitKeysTimeout,
-                    "WaitKeys timeout {:%Y-%m-%d %H:%M:%S}", current_time);
-    state_ = State::kRestreamConnection;
-    return current_time;
-  }
-  return last_request_time_ + response_timeout_;
-}
+void Registration::Restream() { root_server_select_stream_.Restream(); }
 
-void Registration::RequestPowParams() {
-  AE_TELE_INFO(RegisterRequestPowParams, "Request proof of work params");
-
-  // setup crypto config
-  root_crypto_provider_->SetEncryptionKey(server_pub_key_);
-  auto ret_key = root_crypto_provider_->GetDecryptionKey();
-
-  auto api_call = ApiCallAdapter{ApiContext{server_reg_root_api_},
-                                 root_server_select_stream_};
-  api_call->enter(
-      kDefaultCryptoLibProfile,
-      SubApi{[this, &ret_key](ApiContext<ServerRegistrationApi>& server_api) {
-        server_api->set_return_key(std::move(ret_key));
-        auto pow_params_promise = server_api->request_proof_of_work_data(
-            parent_uid_, PowMethod::kBCryptCrc32);
-        response_sub_ =
-            pow_params_promise->StatusEvent().Subscribe(ActionHandler{
-                OnResult{[&](auto& promise) {
-                  auto& pow_params = promise.value();
-                  [[maybe_unused]] auto res =
-                      CryptoSignVerify(pow_params.global_key.sign,
-                                       pow_params.global_key.key, sign_pk_);
+auto Registration::GetKeys() {
+  return make_api_call<ex::set_value_t(Ignore), ex::set_error_t(std::uint32_t)>(
+      server_reg_root_api_, root_server_select_stream_,
+      [&, s{Subscription{}}](ApiContext<RegistrationRootApi>& api_call,
+                             auto& r) mutable noexcept {
+        AE_TELE_INFO(RegisterGetKeys, "GetKeys");
+        s = api_call->get_asymmetric_public_key(kDefaultCryptoLibProfile)
+                .Subscribe([&](auto&& res) mutable noexcept {
                   if (!res) {
-                    AE_TELE_ERROR(
-                        RegisterPowParamsVerificationFailed,
-                        "Proof of work params sign verification failed");
-                    state_ = State::kRegistrationFailed;
+                    ex::set_error(std::move(r), std::move(res).error());
                     return;
                   }
-
-                  aether_global_key_ = pow_params.global_key.key;
-
-                  pow_params_.salt = pow_params.salt;
-                  pow_params_.max_hash_value = pow_params.max_hash_value;
-                  pow_params_.password_suffix = pow_params.password_suffix;
-                  pow_params_.pool_size = pow_params.pool_size;
-
-                  state_ = State::kMakeRegistration;
-                }},
-                OnError{[&]() { state_ = State::kRegistrationFailed; }}});
-      }});
-
-  packet_write_action_ = api_call.Flush();
-
-  reg_server_write_subscription_ =
-      packet_write_action_->StatusEvent().Subscribe(OnError{[this]() {
-        AE_TELED_ERROR("RequestPowParams stream write failed");
-        state_ = State::kRegistrationFailed;
-      }});
+                  auto signed_key = std::move(res).value();
+                  if (!CryptoSignVerify(signed_key.sign, signed_key.key,
+                                        sign_pk_)) {
+                    AE_TELE_ERROR(RegisterGetKeysVerificationFailed,
+                                  "Sign verification failed");
+                    ex::set_error(std::move(r), 1);
+                    return;
+                  }
+                  server_pub_key_ = std::move(signed_key.key);
+                  root_crypto_provider_.SetEncryptionKey(server_pub_key_);
+                  AE_TELED_INFO("Key received");
+                  ex::set_value(std::move(r), Ignore{});
+                });
+      });
 }
 
-void Registration::MakeRegistration() {
-  AE_TELE_INFO(RegisterMakeRegistration, "Make registration");
-
-  // Proof calculation
-  // TODO: move into update method to perform in a limited duration.
-  // NOT TODO: don't send back iterations count and time. An attacker can send
-  // wrong numbers.
-  auto proofs = ProofOfWork::ComputeProofOfWork(
-      pow_params_.pool_size, pow_params_.salt, pow_params_.password_suffix,
-      pow_params_.max_hash_value);
-
-  global_crypto_provider_->SetEncryptionKey(aether_global_key_);
-  client_config_.master_key = global_crypto_provider_->GetDecryptionKey();
-
-  AE_TELE_DEBUG(RegisterKeysGenerated, "Global Pk: {}:{}, Masterkey: {}:{}",
-                aether_global_key_.Index(), aether_global_key_,
-                client_config_.master_key.Index(), client_config_.master_key);
-
-  auto api_call = ApiCallAdapter{ApiContext{server_reg_root_api_},
-                                 root_server_select_stream_};
-  api_call->enter(
-      kDefaultCryptoLibProfile,
-      SubApi{[this, &proofs](ApiContext<ServerRegistrationApi>& server_api) {
-        server_api->registration(
-            pow_params_.salt, pow_params_.password_suffix, proofs, parent_uid_,
-            SubApi{[this](ApiContext<GlobalRegServerApi>& global_api) {
-              // set master key and wait for confirmation
-              global_api->set_master_key(client_config_.master_key);
-              auto confirm_promise = global_api->finish();
-
-              response_sub_ =
-                  confirm_promise->StatusEvent().Subscribe(ActionHandler{
-                      OnResult{[&](auto& promise) {
-                        auto& reg_response = promise.value();
-                        AE_TELE_INFO(RegisterRegistrationConfirmed,
-                                     "Registration confirmed");
-
-                        client_config_.uid = reg_response.uid;
-                        client_config_.ephemeral_uid =
-                            reg_response.ephemeral_uid;
-                        client_config_.parent_uid = parent_uid_;
-
-                        // use client cloud_ for cloud resolve request
-                        client_cloud_ = reg_response.cloud;
-                        assert((client_cloud_.size() > 0) &&
-                               "Client's cloud is empty");
-                        state_ = State::kRequestCloudResolving;
-                      }},
-                      OnError{[&]() { state_ = State::kRegistrationFailed; }}});
+auto Registration::RequestPowParams() {
+  return make_api_call<ex::set_value_t(Ignore), ex::set_error_t(std::uint32_t)>(
+      server_reg_root_api_, root_server_select_stream_,
+      [&, s{Subscription{}}](ApiContext<RegistrationRootApi>& api_call,
+                             auto& r) mutable noexcept {
+        AE_TELE_INFO(RegisterRequestPowParams, "Request proof of work params");
+        api_call->enter(
+            kDefaultCryptoLibProfile,
+            SubApi{[&](ApiContext<ServerRegistrationApi>& server_api) {
+              server_api->set_return_key(
+                  root_crypto_provider_.GetDecryptionKey());
+              s = server_api
+                      ->request_proof_of_work_data(parent_uid_,
+                                                   PowMethod::kBCryptCrc32)
+                      .Subscribe([&](auto&& res) mutable noexcept {
+                        if (!res) {
+                          ex::set_error(std::move(r), std::move(res).error());
+                          return;
+                        }
+
+                        auto pow_params = std::move(res).value();
+                        if (!CryptoSignVerify(pow_params.global_key.sign,
+                                              pow_params.global_key.key,
+                                              sign_pk_)) {
+                          AE_TELE_ERROR(
+                              RegisterPowParamsVerificationFailed,
+                              "Proof of work params sign verification failed");
+                          ex::set_error(std::move(r), 2);
+                          return;
+                        }
+
+                        aether_global_key_ = pow_params.global_key.key;
+                        pow_params_.salt = pow_params.salt;
+                        pow_params_.max_hash_value = pow_params.max_hash_value;
+                        pow_params_.password_suffix =
+                            pow_params.password_suffix;
+                        pow_params_.pool_size = pow_params.pool_size;
+
+                        global_crypto_provider_.SetEncryptionKey(
+                            aether_global_key_);
+                        master_key_ =
+                            global_crypto_provider_.GetDecryptionKey();
+
+                        ex::set_value(std::move(r), Ignore{});
+                      });
             }});
-      }});
-
-  packet_write_action_ = api_call.Flush();
+      });
+}
 
-  reg_server_write_subscription_ =
-      packet_write_action_->StatusEvent().Subscribe(OnError{[this]() {
-        AE_TELED_ERROR("MakeRegistration stream write failed");
-        state_ = State::kRegistrationFailed;
-      }});
+auto Registration::MakeRegistration() {
+  return make_api_call<ex::set_value_t(Ignore), ex::set_error_t(std::uint32_t)>(
+      server_reg_root_api_, root_server_select_stream_,
+      [&, s{Subscription{}}](ApiContext<RegistrationRootApi>& api_call,
+                             auto& r) mutable noexcept {
+        AE_TELE_INFO(RegisterMakeRegistration, "Make registration");
+
+        // Proof calculation
+        auto proofs = ProofOfWork::ComputeProofOfWork(
+            pow_params_.pool_size, pow_params_.salt,
+            pow_params_.password_suffix, pow_params_.max_hash_value);
+
+        AE_TELE_DEBUG(RegisterKeysGenerated,
+                      "Global Pk: {}:{}, Masterkey: {}:{}",
+                      aether_global_key_.Index(), aether_global_key_,
+                      master_key_.Index(), master_key_);
+
+        api_call->enter(
+            kDefaultCryptoLibProfile,
+            SubApi{[&](ApiContext<ServerRegistrationApi>& server_api) {
+              server_api->registration(
+                  pow_params_.salt, pow_params_.password_suffix, proofs,
+                  parent_uid_,
+                  SubApi{[&](ApiContext<GlobalRegServerApi>& global_api) {
+                    // set master key and wait for confirmation
+                    global_api->set_master_key(master_key_);
+                    s = global_api->finish().Subscribe(
+                        [&, r{std::forward<decltype(r)>(r)}](
+                            auto&& res) mutable noexcept {
+                          if (!res) {
+                            ex::set_error(std::move(r), std::move(res).error());
+                            return;
+                          }
+                          AE_TELE_INFO(RegisterRegistrationConfirmed,
+                                       "Registration confirmed");
+                          client_uid_ = res.value().uid;
+                          ephemeral_uid_ = res.value().ephemeral_uid;
+                          // use client cloud_ for cloud resolve request
+                          client_cloud_ = res.value().cloud;
+                          assert((client_cloud_.size() > 0) &&
+                                 "Client's cloud is empty");
+                          ex::set_value(std::move(r), Ignore{});
+                        });
+                  }});
+            }});
+      });
 }
 
-void Registration::ResolveCloud() {
-  AE_TELE_INFO(RegisterResolveCloud, "Resolve cloud as [{}]", client_cloud_);
-
-  auto api_call = ApiCallAdapter{ApiContext{server_reg_root_api_},
-                                 root_server_select_stream_};
-  api_call->enter(
-      kDefaultCryptoLibProfile,
-      SubApi{[this](ApiContext<ServerRegistrationApi>& server_api) {
-        auto resolve_cloud_promise = server_api->resolve_servers(client_cloud_);
-        response_sub_ =
-            resolve_cloud_promise->StatusEvent().Subscribe(ActionHandler{
-                OnResult{
-                    [&](auto& promise) { OnCloudResolved(promise.value()); }},
-                OnError{[&]() { state_ = State::kRegistrationFailed; }}});
-      }});
-
-  packet_write_action_ = api_call.Flush();
-
-  reg_server_write_subscription_ =
-      packet_write_action_->StatusEvent().Subscribe(OnError{[this]() {
-        AE_TELED_ERROR("ResolveCloud stream write failed");
-        state_ = State::kRegistrationFailed;
-      }});
+auto Registration::ResolveCloud() {
+  return make_api_call<ex::set_value_t(ClientConfig),
+                       ex::set_error_t(std::uint32_t)>(
+      server_reg_root_api_, root_server_select_stream_,
+      [&, s{Subscription{}}](ApiContext<RegistrationRootApi>& api_call,
+                             auto& r) mutable noexcept {
+        AE_TELE_INFO(RegisterResolveCloud, "Resolve cloud as [{}]",
+                     client_cloud_);
+
+        api_call->enter(
+            kDefaultCryptoLibProfile,
+            SubApi{[&](ApiContext<ServerRegistrationApi>&
+                           server_api) mutable noexcept {
+              s = server_api->resolve_servers(client_cloud_)
+                      .Subscribe([&](auto&& res) {
+                        if (res) {
+                          ex::set_value(
+                              std::move(r),
+                              OnCloudResolved(std::move(res).value()));
+                        } else {
+                          ex::set_error(std::move(r), std::move(res).error());
+                        }
+                      });
+            }});
+      });
 }
 
-void Registration::OnCloudResolved(
+ClientConfig Registration::OnCloudResolved(
     std::vector<ServerDescriptor> const& servers) {
   AE_TELE_INFO(RegisterResolveCloudResponse);
 
+  ClientConfig client_config{
+      .parent_uid = parent_uid_,
+      .uid = client_uid_,
+      .ephemeral_uid = ephemeral_uid_,
+      .master_key = master_key_,
+      .cloud = {},
+  };
+
   std::vector<Server::ptr> server_objects;
   server_objects.reserve(servers.size());
 
@@ -339,12 +271,12 @@ void Registration::OnCloudResolved(
     }
     AE_TELED_DEBUG("Got server {} with endpoints {}", description.server_id,
                    endpoints);
-    client_config_.cloud.emplace_back(
+    client_config.cloud.emplace_back(
         ServerConfig{description.server_id, std::move(endpoints)});
   }
 
   // sort cloud by order of client_cloud_
-  std::sort(std::begin(client_config_.cloud), std::end(client_config_.cloud),
+  std::sort(std::begin(client_config.cloud), std::end(client_config.cloud),
             [this](auto const& left, auto const& right) {
               auto left_order = std::find(std::begin(client_cloud_),
                                           std::end(client_cloud_), left.id);
@@ -355,8 +287,56 @@ void Registration::OnCloudResolved(
 
   AE_TELE_DEBUG(RegisterClientRegistered,
                 "Client registered:\n>>>>>>>>>>>>>>>\n{}\n<<<<<<<<<<<<<<<",
-                client_config_);
-  state_ = State::kRegistered;
+                client_config);
+
+  return client_config;
+}
+
+void Registration::Run() {
+  auto s =
+      // try to get keys a few times
+      ex::for_range(Range{0, 4},
+                    [&](auto) {
+                      return GetKeys() |
+                             ex::with_timeout(ae_context_, response_timeout_) |
+                             ex::upon_error(Override{
+                                 [&](ex::TimeoutError) {
+                                   AE_TELE_WARNING(RegisterWaitKeysTimeout,
+                                                   "WaitKeys timeout");
+                                   Restream();
+                                   return ex::for_continue;
+                                 },
+                                 [&](auto&&...) noexcept {
+                                   Restream();
+                                   return ex::for_continue;
+                                 }});
+                    }) |
+      ex::let_stopped([&]() noexcept { return ex::just_error(1); }) |
+      // perform the rest of the registration process
+      ex::let_value([&](auto&&) noexcept { return RequestPowParams(); }) |
+      ex::let_value([&](auto&&) noexcept { return MakeRegistration(); }) |
+      ex::let_value([&](auto&&) noexcept { return ResolveCloud(); }) |
+      ex::let_error(Override{
+          [&](std::uint32_t e) noexcept {
+            AE_TELED_ERROR("Registration failed with error code: {}", e);
+            return ex::just_error(static_cast<int>(e));
+          },
+          [&](WriteFailed) noexcept {
+            AE_TELED_ERROR("Registration failed with write error");
+            return ex::just_error(-1);
+          },
+          [&](auto&&...) noexcept {
+            AE_TELED_ERROR("Registration failed");
+            return ex::just_error(-1);
+          }});
+
+  async_waiter_.emplace(
+      ae_context_, std::move(s),
+      [&](std::optional<Result<ClientConfig, int>>&& res) noexcept {
+        assert(res);
+        registration_event_.Emit(std::move(res).value());
+        finished_event_.Emit();
+      });
 }
 }  // namespace ae
 #endif
diff --git a/aether/registration/registration.h b/aether/registration/registration.h
index 62a5f73d..e4bb70a9 100644
--- a/aether/registration/registration.h
+++ b/aether/registration/registration.h
@@ -22,90 +22,73 @@
 #if AE_SUPPORT_REGISTRATION
 
 #  include <vector>
+#  include <optional>
 
-#  include "aether/common.h"
-#  include "aether/memory.h"
 #  include "aether/types/uid.h"
-#  include "aether/actions/action.h"
-#  include "aether/actions/action_ptr.h"
-#  include "aether/types/state_machine.h"
+#  include "aether/crypto/key.h"
+#  include "aether/events/events.h"
+#  include "aether/types/server_id.h"
 #  include "aether/types/client_config.h"
+#  include "aether/executors/executors.h"
+#  include "aether/types/small_function.h"
 
 #  include "aether/registration_cloud.h"
 #  include "aether/registration/api/client_reg_api_unsafe.h"
 #  include "aether/registration/api/registration_root_api.h"
 #  include "aether/registration/root_server_select_stream.h"
+#  include "aether/registration/registration_crypto_provider.h"
 
 namespace ae {
-
-class Aether;
-
-class Registration final : public Action<Registration> {
-  enum class State : std::uint8_t {
-    kInitConnection,
-    kRestreamConnection,
-    kGetKeys,
-    kWaitKeys,
-    kGetPowParams,
-    kMakeRegistration,
-    kRequestCloudResolving,
-    kRegistered,
-    kRegistrationFailed,
-  };
-
+class Registration {
  public:
-  Registration(ActionContext action_context, Aether& aether,
-               Ptr<RegistrationCloud> const& reg_cloud, Uid parent_uid);
-  ~Registration() override;
+  using RegistrationEvent = Event<void(Result<ClientConfig, int>)>;
+  using FinishedEvent = Event<void()>;
 
-  UpdateStatus Update();
+  Registration(AeContext const& ae_context,
+               Ptr<RegistrationCloud> const& reg_cloud, Uid parent_uid);
+  ~Registration();
 
-  ClientConfig const& client_config() const;
+  RegistrationEvent::Subscriber registration();
+  FinishedEvent::Subscriber IsFinished();
 
  private:
   void InitConnection();
   void Restream();
-  void GetKeys();
-  TimePoint WaitKeys();
-  void RequestPowParams();
-  void MakeRegistration();
-  void ResolveCloud();
-  void OnCloudResolved(std::vector<ServerDescriptor> const& servers);
-
-  ActionContext action_context_;
+  void Run();
+  auto GetKeys();
+  auto RequestPowParams();
+  auto MakeRegistration();
+  auto ResolveCloud();
+  ClientConfig OnCloudResolved(std::vector<ServerDescriptor> const& servers);
+
+  AeContext ae_context_;
   Uid parent_uid_;
 
   ProtocolContext protocol_context_;
-
-  std::unique_ptr<class RegistrationCryptoProvider> root_crypto_provider_;
-  std::unique_ptr<class RegistrationCryptoProvider> global_crypto_provider_;
-
+  RegistrationCryptoProvider root_crypto_provider_;
+  RegistrationCryptoProvider global_crypto_provider_;
   ClientRegRootApi client_root_api_;
   RegistrationRootApi server_reg_root_api_;
-
   RootServerSelectStream root_server_select_stream_;
 
-  StateMachine<State> state_;
-
   Duration response_timeout_;
-  TimePoint last_request_time_;
 
   Key server_pub_key_;
-  Uid uid_;
-  Uid ephemeral_uid_;
   Key sign_pk_;
   PowParams pow_params_;
   Key aether_global_key_;
   std::vector<ServerId> client_cloud_;
+  Key master_key_;
+  Uid client_uid_;
+  Uid ephemeral_uid_;
 
-  ClientConfig client_config_;
-
-  ActionPtr<WriteAction> packet_write_action_;
-  Subscription data_read_subscription_;
-  Subscription raw_transport_send_action_subscription_;
-  Subscription reg_server_write_subscription_;
-  Subscription response_sub_;
-  Subscription state_change_subscription_;
+  std::optional<ex::AsyncWaiter<
+      ex::AnySender<ex::set_value_t(ClientConfig), ex::set_error_t(int),
+                    ex::set_stopped_t()>,
+      SmallFunction<void(std::optional<Result<ClientConfig, int>>&&)>>>
+      async_waiter_;
+  RegistrationEvent registration_event_;
+  FinishedEvent finished_event_;
 };
 }  // namespace ae
 
diff --git a/aether/server_connections/client_server_connection.cpp b/aether/server_connections/client_server_connection.cpp
index 343d94bc..fd16d2d5 100644
--- a/aether/server_connections/client_server_connection.cpp
+++ b/aether/server_connections/client_server_connection.cpp
@@ -102,8 +102,7 @@ ClientServerConnection::ClientServerConnection(AeContext const& ae_context,
       crypto_provider_{std::make_unique<_internal::ClientCryptoProvider>(
           client, server->server_id)},
       client_api_unsafe_{protocol_context_, *crypto_provider_->decryptor()},
-      login_api_{protocol_context_, ae_context_.aether(),
-                 *crypto_provider_->encryptor()},
+      login_api_{protocol_context_, *crypto_provider_->encryptor()},
       server_connection_{ae_context_, server} {
   AE_TELED_DEBUG("Client server connection from {} to {}", ephemeral_uid_,
                  server->server_id);
diff --git a/aether/types/result.h b/aether/types/result.h
index d3a01ca1..0dbafbc3 100644
--- a/aether/types/result.h
+++ b/aether/types/result.h
@@ -23,8 +23,6 @@
 #include <functional>
 #include <type_traits>
 
-#include "aether/meta/as_type.h"
-
 namespace ae {
 template <typename T, typename E>
 class Result;
@@ -70,14 +68,17 @@ class Result {
   explicit Result(EU&& error) : storage_{std::forward<EU>(error)} {}
 
   // made implicit intentionally
-  Result(Ok<T>&& ok) : storage_{std::move(ok.value)} {}
+  constexpr Result(Ok<T>&& ok)  // NOLINT(*explicit-constructor)
+      : storage_{std::move(ok).value} {}
   // made implicit intentionally
-  Result(Error<E>&& error) : storage_{std::move(error.error)} {}
-
-  // TODO: add monadic operations
+  constexpr Result(Error<E>&& error)  // NOLINT(*explicit-constructor)
+      : storage_{std::move(error).error} {}
 
-  bool IsOk() const noexcept { return storage_.index() == 0; }
-  bool IsErr() const noexcept { return storage_.index() == 1; }
+  constexpr bool IsOk() const noexcept { return storage_.index() == 0; }
+  constexpr bool IsErr() const noexcept { return storage_.index() == 1; }
+  constexpr explicit operator bool() const noexcept {
+    return storage_.index() == 0;
+  }
 
   auto& value() & noexcept {
     assert(IsOk());
@@ -159,9 +160,9 @@ class Result {
 
  private:
   value_type* get_value() & { return std::get_if<0>(&storage_); }
-  value_type* get_value() const& { return std::get_if<0>(&storage_); }
+  value_type const* get_value() const& { return std::get_if<0>(&storage_); }
   error_type* get_error() & { return std::get_if<1>(&storage_); }
-  error_type* get_error() const& { return std::get_if<1>(&storage_); }
+  error_type const* get_error() const& { return std::get_if<1>(&storage_); }
 
   std::variant<value_type, error_type> storage_;
 };
diff --git a/aether/uap/uap.cpp b/aether/uap/uap.cpp
index 3311d9e3..0d188f60 100644
--- a/aether/uap/uap.cpp
+++ b/aether/uap/uap.cpp
@@ -174,7 +174,7 @@ void Uap::WindowWatcher() {
   }
 
   aether_.WithLoaded([this, w{current.window}](auto const& a) {
-    auto timer_action = ActionPtr<TimerAction>{*a, w};
+    auto timer_action = ActionPtr<TimerAction>{ActionContext{*a}, w};
     RegisterAction(*timer_action);
   });
 }
diff --git a/aether/work_cloud_api/work_server_api/authorized_api.cpp b/aether/work_cloud_api/work_server_api/authorized_api.cpp
index 5768be8a..2c35cd74 100644
--- a/aether/work_cloud_api/work_server_api/authorized_api.cpp
+++ b/aether/work_cloud_api/work_server_api/authorized_api.cpp
@@ -17,13 +17,12 @@
 #include "aether/work_cloud_api/work_server_api/authorized_api.h"
 
 namespace ae {
-AuthorizedApi::AuthorizedApi(ProtocolContext& protocol_context,
-                             ActionContext action_context)
+AuthorizedApi::AuthorizedApi(ProtocolContext& protocol_context)
     : ApiClass{protocol_context},
-      ping{protocol_context, action_context},
+      ping{protocol_context},
       send_message{protocol_context},
       send_messages{protocol_context},
-      check_access_for_send_message{protocol_context, action_context},
+      check_access_for_send_message{protocol_context},
       resolver_servers{protocol_context},
       resolver_clouds{protocol_context},
       send_telemetry{protocol_context} {}
diff --git a/aether/work_cloud_api/work_server_api/authorized_api.h b/aether/work_cloud_api/work_server_api/authorized_api.h
index b7960f76..bd744377 100644
--- a/aether/work_cloud_api/work_server_api/authorized_api.h
+++ b/aether/work_cloud_api/work_server_api/authorized_api.h
@@ -30,13 +30,12 @@ namespace ae {
 
 class AuthorizedApi : public ApiClass {
  public:
-  AuthorizedApi(ProtocolContext& protocol_context,
-                ActionContext action_context);
+  explicit AuthorizedApi(ProtocolContext& protocol_context);
 
-  Method<4, ApiPromisePtr<void>(std::uint64_t next_connect_ms_duration)> ping;
+  Method<4, ApiPromise<void>(std::uint64_t next_connect_ms_duration)> ping;
   Method<6, void(AeMessage message)> send_message;
   Method<7, void(std::vector<AeMessage> messages)> send_messages;
-  Method<11, ApiPromisePtr<void>(Uid uid)> check_access_for_send_message;
+  Method<11, ApiPromise<void>(Uid uid)> check_access_for_send_message;
   Method<12, void(std::vector<ServerId> sids)> resolver_servers;
   Method<13, void(std::vector<Uid> uids)> resolver_clouds;
 
diff --git a/aether/work_cloud_api/work_server_api/login_api.cpp b/aether/work_cloud_api/work_server_api/login_api.cpp
index 8ba3c55b..ea60f705 100644
--- a/aether/work_cloud_api/work_server_api/login_api.cpp
+++ b/aether/work_cloud_api/work_server_api/login_api.cpp
@@ -20,14 +20,13 @@
 
 namespace ae {
 LoginApi::LoginApi(ProtocolContext& protocol_context,
-                   ActionContext action_context,
                    IEncryptProvider& encrypt_provider)
     : ApiClass{protocol_context},
-      get_time_utc{protocol_context, action_context},
+      get_time_utc{protocol_context},
       login_by_uid{protocol_context, LoginProc{*this}},
       login_by_alias{protocol_context, LoginProc{*this}},
       encrypt_provider_{&encrypt_provider},
-      auth_api_{protocol_context, action_context} {}
+      auth_api_{protocol_context} {}
 
 DataBuffer LoginApi::Encrypt(DataBuffer const& data) {
   AE_TELED_DEBUG("Login api data {}", data);
diff --git a/aether/work_cloud_api/work_server_api/login_api.h b/aether/work_cloud_api/work_server_api/login_api.h
index ef1c79e2..2554705d 100644
--- a/aether/work_cloud_api/work_server_api/login_api.h
+++ b/aether/work_cloud_api/work_server_api/login_api.h
@@ -41,10 +41,9 @@ class LoginApi : public ApiClass {
 
  public:
   explicit LoginApi(ProtocolContext& protocol_context,
-                    ActionContext action_context,
                     IEncryptProvider& encrypt_provider);
 
-  Method<3, ApiPromisePtr<std::uint64_t>()> get_time_utc;
+  Method<3, ApiPromise<std::uint64_t>()> get_time_utc;
   Method<4, void(Uid uid, SubApi<AuthorizedApi> sub_api), LoginProc>
       login_by_uid;
   Method<5, void(Uid alias, SubApi<AuthorizedApi> sub_api), LoginProc>
diff --git a/examples/benches/send_messages_bandwidth/common/bandwidth_api.cpp b/examples/benches/send_messages_bandwidth/common/bandwidth_api.cpp
index ea4f504d..67abc320 100644
--- a/examples/benches/send_messages_bandwidth/common/bandwidth_api.cpp
+++ b/examples/benches/send_messages_bandwidth/common/bandwidth_api.cpp
@@ -17,12 +17,11 @@
 #include "send_messages_bandwidth/common/bandwidth_api.h"
 
 namespace ae::bench {
-BandwidthApi::BandwidthApi(ActionContext action_context,
-                           ProtocolContext& protocol_context)
+BandwidthApi::BandwidthApi(ProtocolContext& protocol_context)
     : ApiClassImpl{protocol_context},
-      handshake{protocol_context, action_context},
-      start_test{protocol_context, action_context},
-      stop_test{protocol_context, action_context},
+      handshake{protocol_context},
+      start_test{protocol_context},
+      stop_test{protocol_context},
       message{protocol_context},
       return_result{protocol_context} {}
 
diff --git a/examples/benches/send_messages_bandwidth/common/bandwidth_api.h b/examples/benches/send_messages_bandwidth/common/bandwidth_api.h
index dbb04161..3487285f 100644
--- a/examples/benches/send_messages_bandwidth/common/bandwidth_api.h
+++ b/examples/benches/send_messages_bandwidth/common/bandwidth_api.h
@@ -28,14 +28,14 @@ class BandwidthApi : public ApiClassImpl<BandwidthApi> {
  public:
   using PayloadData = DataBuffer;
 
-  BandwidthApi(ActionContext action_context, ProtocolContext& protocol_context);
+  explicit BandwidthApi(ProtocolContext& protocol_context);
 
   // sender sends handshake until receiver doesn't answers true
-  Method<0x03, ApiPromisePtr<bool>()> handshake;
+  Method<0x03, ApiPromise<bool>()> handshake;
   // sender sends start or stop test and wait for receiver's response true to
   // continue/stop tests
-  Method<0x04, ApiPromisePtr<bool>()> start_test;
-  Method<0x05, ApiPromisePtr<bool>()> stop_test;
+  Method<0x04, ApiPromise<bool>()> start_test;
+  Method<0x05, ApiPromise<bool>()> stop_test;
 
   Method<0x06, void(std::uint16_t id, PayloadData data)> message;
 
diff --git a/examples/benches/send_messages_bandwidth/receiver/receiver.cpp b/examples/benches/send_messages_bandwidth/receiver/receiver.cpp
index 8071d170..72f652f1 100644
--- a/examples/benches/send_messages_bandwidth/receiver/receiver.cpp
+++ b/examples/benches/send_messages_bandwidth/receiver/receiver.cpp
@@ -25,7 +25,7 @@ namespace ae::bench {
 Receiver::Receiver(ActionContext action_context, Client::ptr client)
     : action_context_{action_context},
       client_{std::move(client)},
-      bandwidth_api_{action_context, protocol_context_} {}
+      bandwidth_api_{protocol_context_} {}
 
 EventSubscriber<void()> Receiver::error_event() { return error_event_; }
 
diff --git a/examples/benches/send_messages_bandwidth/sender/sender.cpp b/examples/benches/send_messages_bandwidth/sender/sender.cpp
index 928cad41..5f972473 100644
--- a/examples/benches/send_messages_bandwidth/sender/sender.cpp
+++ b/examples/benches/send_messages_bandwidth/sender/sender.cpp
@@ -28,7 +28,7 @@ Sender::Sender(ActionContext action_context, Client::ptr client,
     : action_context_{action_context},
       client_{std::move(client)},
       destination_{destination},
-      bandwidth_api_{action_context_, protocol_context_} {}
+      bandwidth_api_{protocol_context_} {}
 
 EventSubscriber<void()> Sender::error_event() { return error_event_; }
 
@@ -45,18 +45,17 @@ void Sender::Disconnect() { message_stream_.Reset(); }
 EventSubscriber<void()> Sender::Handshake() {
   auto api = ApiCallAdapter{ApiContext{bandwidth_api_}, *message_stream_};
 
-  auto res = api->handshake();
-  handshake_sub_ =
-      res->StatusEvent().Subscribe(OnResult{[this](auto const& promise) {
-        AE_TELED_DEBUG("Handshake received");
-        if (promise.value()) {
-          handshake_made_.Emit();
-        } else {
-          error_event_.Emit();
-        }
-      }});
-
-  AE_TELED_DEBUG("Sending handshake request {}", res->request_id());
+  auto& res = api->handshake();
+  handshake_sub_ = res.Subscribe([this](auto const& res) {
+    AE_TELED_DEBUG("Handshake received");
+    if (res && res.value()) {
+      handshake_made_.Emit();
+    } else {
+      error_event_.Emit();
+    }
+  });
+
+  AE_TELED_DEBUG("Sending handshake request {}", res.request_id());
   api.Flush();
 
   return handshake_made_;
@@ -103,11 +102,12 @@ EventSubscriber<void()> Sender::StartTest() {
         AE_TELED_DEBUG("Sending start test request");
         auto api = ApiCallAdapter{ApiContext{bandwidth_api_}, *message_stream_};
 
-        auto res = api->start_test();
-        sync_subs_.Push(res->StatusEvent().Subscribe(OnResult{[this]() {
-          start_test_action_->Stop();
-          test_started_event_.Emit();
-        }}));
+        sync_subs_ += api->start_test().Subscribe([this](auto const& res) {
+          if (res.IsOk()) {
+            start_test_action_->Stop();
+            test_started_event_.Emit();
+          }
+        });
         api.Flush();
       },
       std::chrono::seconds{1}, 5};
@@ -125,11 +125,12 @@ EventSubscriber<void()> Sender::StopTest() {
         AE_TELED_DEBUG("Sending stop test request");
         auto api = ApiCallAdapter{ApiContext{bandwidth_api_}, *message_stream_};
 
-        auto res = api->stop_test();
-        sync_subs_.Push(res->StatusEvent().Subscribe(OnResult{[this]() {
-          stop_test_action_->Stop();
-          test_stopped_event_.Emit();
-        }}));
+        sync_subs_ += api->stop_test().Subscribe([this](auto const& res) {
+          if (res.IsOk()) {
+            stop_test_action_->Stop();
+            test_stopped_event_.Emit();
+          }
+        });
         api.Flush();
       },
       std::chrono::seconds{1}, 5};
diff --git a/tests/test-api-protocol/test-method-call.cpp b/tests/test-api-protocol/test-method-call.cpp
index 86f464a1..952b3886 100644
--- a/tests/test-api-protocol/test-method-call.cpp
+++ b/tests/test-api-protocol/test-method-call.cpp
@@ -56,11 +56,11 @@ class ApiLevel0 : public ApiClassImpl<ApiLevel0> {
   };
 
  public:
-  ApiLevel0(ProtocolContext& protocol_context, ActionContext action_context)
+  explicit ApiLevel0(ProtocolContext& protocol_context)
       : ApiClassImpl{protocol_context},
         api_level1{protocol_context},
         method_3{protocol_context},
-        method_4{protocol_context, action_context},
+        method_4{protocol_context},
         method_5{protocol_context, api_level1},
         method_6{protocol_context, Method6Proc{api_level1}},
         return_result_api{protocol_context} {}
@@ -87,7 +87,7 @@ class ApiLevel0 : public ApiClassImpl<ApiLevel0> {
 
   // call methods to make packet
   Method<03, void(int a, std::string b)> method_3;
-  Method<04, ApiPromisePtr<int>(int a)> method_4;
+  Method<04, ApiPromise<int>(int a)> method_4;
   Method<05, SubContext<ApiLevel1>(int a)> method_5;
   Method<06, void(int a, SubApi<ApiLevel1> sub), Method6Proc> method_6;
 
@@ -102,7 +102,7 @@ void test_ApiMethodInvoke() {
   ActionProcessor ap;
   ProtocolContext pc;
 
-  auto api_level0 = ApiLevel0{pc, ActionContext{ap}};
+  auto api_level0 = ApiLevel0{pc};
   auto call_context = ApiContext{api_level0};
 
   call_context->method_3(12, "asd");
@@ -139,17 +139,19 @@ void test_ReturnResult() {
 
   bool promise_get_value = false;
 
-  auto api_level0 = ApiLevel0{pc, ActionContext{ap}};
+  auto api_level0 = ApiLevel0{pc};
   auto call_context = ApiContext{api_level0};
 
-  auto promise = call_context->method_4(42);
-  promise->StatusEvent().Subscribe(
-      ActionHandler{OnResult{[&](auto const& promise) {
-                      auto value = promise.value();
-                      TEST_ASSERT_EQUAL(78, value);
-                      promise_get_value = true;
-                    }},
-                    OnError{[]() { TEST_FAIL(); }}});
+  auto& promise = call_context->method_4(42);
+  promise.Subscribe([&](auto const& res) {
+    if (res.IsOk()) {
+      auto value = res.value();
+      TEST_ASSERT_EQUAL(78, value);
+      promise_get_value = true;
+    } else {
+      TEST_FAIL();
+    }
+  });
 
   DataBuffer packet = std::move(call_context);
 
@@ -182,7 +184,7 @@ void test_MethodWithSubApi() {
   ActionProcessor ap;
   ProtocolContext pc;
 
-  auto api_level0 = ApiLevel0{pc, ActionContext{ap}};
+  auto api_level0 = ApiLevel0{pc};
   auto call_context = ApiContext{api_level0};
 
   call_context->method_6(
diff --git a/tools/registrator/registrator_action.cpp b/tools/registrator/registrator_action.cpp
index 889d1816..f869f7ca 100644
--- a/tools/registrator/registrator_action.cpp
+++ b/tools/registrator/registrator_action.cpp
@@ -65,23 +65,23 @@ void RegistratorAction::RegisterClients(
   for (auto const& c : client_configs) {
     auto parent_uid = ae::Uid::FromString(c.parent_uid);
     assert(!parent_uid.empty());
-    auto reg_action = aether->RegisterClient(parent_uid);
-    registration_sub_ += reg_action->StatusEvent().Subscribe(ActionHandler{
-        OnResult{
-            [this, clients_count, client_id{&c.client_id}](auto const& action) {
-              registered_clients_.emplace_back(RegisteredClient{
-                  action.client_config(),
-                  *client_id,
-              });
-              if (registered_clients_.size() == clients_count) {
-                state_ = State::kResult;
+
+    registration_sub_ +=
+        aether->RegisterClient(c.client_id, parent_uid)
+            .registration()
+            .Subscribe([this, clients_count,
+                        client_id{&c.client_id}](auto const& res) {
+              if (res) {
+                registered_clients_.emplace_back(
+                    RegisteredClient{res.value(), *client_id});
+                if (registered_clients_.size() == clients_count) {
+                  state_ = State::kResult;
+                }
+              } else {
+                AE_TELED_ERROR("Registration error");
+                state_ = State::kError;
               }
-            }},
-        OnError{[this]() {
-          AE_TELED_ERROR("Registration error");
-          state_ = State::kError;
-        }},
-    });
+            });
   }
 #endif
 }