diff --git a/include/beman/execution/detail/affine.hpp b/include/beman/execution/detail/affine.hpp
index 7b3be2fe..80d48725 100644
--- a/include/beman/execution/detail/affine.hpp
+++ b/include/beman/execution/detail/affine.hpp
@@ -30,7 +30,7 @@ import beman.execution.detail.sender_adaptor_closure;
 import beman.execution.detail.sender_for;
 import beman.execution.detail.set_value;
 import beman.execution.detail.store_receiver;
-import beman.execution.detail.unstoppable;
+import beman.execution.detail.unstoppable_scheduler;
 #else
 #include <beman/execution/detail/basic_sender.hpp>
 #include <beman/execution/detail/continues_on.hpp>
@@ -48,31 +48,12 @@ import beman.execution.detail.unstoppable;
 #include <beman/execution/detail/sender_for.hpp>
 #include <beman/execution/detail/set_value.hpp>
 #include <beman/execution/detail/store_receiver.hpp>
-#include <beman/execution/detail/unstoppable.hpp>
+#include <beman/execution/detail/unstoppable_scheduler.hpp>
 #endif
 
 // ----------------------------------------------------------------------------
 
 namespace beman::execution::detail {
-template <typename Sched>
-struct unstoppable_scheduler {
-    using scheduler_concept = typename Sched::scheduler_concept;
-
-    template <typename Q, typename... Args>
-        requires requires { ::std::declval<Sched>().query(::std::declval<const Q&>(), ::std::declval<Args>()...); }
-    auto query(const Q& q, Args&&... args) const noexcept -> decltype(auto) {
-        return sched.query(q, ::std::forward<Args>(args)...);
-    }
-
-    auto schedule() const noexcept(std::is_nothrow_invocable_v<::beman::execution::schedule_t, Sched>) {
-        return ::beman::execution::unstoppable(::beman::execution::schedule(sched));
-    }
-
-    friend auto operator==(const unstoppable_scheduler& lhs, const unstoppable_scheduler& rhs) -> bool = default;
-
-    Sched sched;
-};
-
 /**
  * @brief The affine_t struct is a sender adaptor closure that transforms a sender
  *        to complete on the scheduler obtained from the receiver's environment.
diff --git a/include/beman/execution/detail/associate.hpp b/include/beman/execution/detail/associate.hpp
index 2969e692..4638b027 100644
--- a/include/beman/execution/detail/associate.hpp
+++ b/include/beman/execution/detail/associate.hpp
@@ -18,10 +18,10 @@ import beman.execution.detail.basic_sender;
 import beman.execution.detail.connect;
 import beman.execution.detail.connect_result_t;
 import beman.execution.detail.completion_signatures;
-import beman.execution.detail.completion_signatures_for;
 import beman.execution.detail.default_impls;
 import beman.execution.detail.env;
 import beman.execution.detail.forward_like;
+import beman.execution.detail.get_completion_signatures;
 import beman.execution.detail.impls_for;
 import beman.execution.detail.make_sender;
 import beman.execution.detail.nothrow_callable;
@@ -35,6 +35,7 @@ import beman.execution.detail.valid_completion_signatures;
 #else
 #include <beman/execution/detail/connect.hpp>
 #include <beman/execution/detail/default_impls.hpp>
+#include <beman/execution/detail/get_completion_signatures.hpp>
 #include <beman/execution/detail/impls_for.hpp>
 #include <beman/execution/detail/make_sender.hpp>
 #include <beman/execution/detail/nothrow_callable.hpp>
@@ -118,7 +119,7 @@ struct associate_t {
     static consteval auto get_completion_signatures() {
         using Data         = decltype(std::declval<::std::remove_cvref_t<Sender>>().template get<1>());
         using child_type_t = ::std::remove_cvref_t<typename ::std::remove_cvref_t<Data>::wrap_sender>;
-        return ::beman::execution::detail::completion_signatures_for<child_type_t, Env...>{};
+        return ::beman::execution::get_completion_signatures<child_type_t, Env...>();
     }
 
     struct impls_for : ::beman::execution::detail::default_impls {
diff --git a/include/beman/execution/detail/basic_sender.hpp b/include/beman/execution/detail/basic_sender.hpp
index a013a89b..2cfb610d 100644
--- a/include/beman/execution/detail/basic_sender.hpp
+++ b/include/beman/execution/detail/basic_sender.hpp
@@ -74,7 +74,7 @@ struct basic_sender : ::beman::execution::detail::product_type<Tag, Data, Child.
     auto get_env() const noexcept -> decltype(auto) {
         auto&& d{this->template get<1>()};
         return sub_apply.at<2>(
-            [&d](auto&&... c) { return ::beman::execution::detail::impls_for<Tag>::get_attrs(d, c...); }, *this);
+            [&d](auto&&... c) { return ::beman::execution::detail::get_impls_for<Tag>::get_attrs()(d, c...); }, *this);
     }
 
     template <typename Receiver>
@@ -114,7 +114,7 @@ struct basic_sender : ::beman::execution::detail::product_type<Tag, Data, Child.
 #endif
     template <::beman::execution::detail::decays_to<basic_sender> Self, typename... Env>
         requires(sizeof...(Env) == 1) || (... && !::beman::execution::dependent_sender<Child>)
-    static consteval auto get_completion_signatures() noexcept {
+    static consteval auto get_completion_signatures() {
         if constexpr (requires { Tag::template get_completion_signatures<Self, Env...>(); })
             return Tag::template get_completion_signatures<Self, Env...>();
         else
diff --git a/include/beman/execution/detail/continues_on.hpp b/include/beman/execution/detail/continues_on.hpp
index d630b6f0..f626a50f 100644
--- a/include/beman/execution/detail/continues_on.hpp
+++ b/include/beman/execution/detail/continues_on.hpp
@@ -25,9 +25,12 @@ import beman.execution.detail.connect;
 import beman.execution.detail.connect_result_t;
 import beman.execution.detail.decayed_tuple;
 import beman.execution.detail.default_impls;
+import beman.execution.detail.env;
 import beman.execution.detail.env_of_t;
 import beman.execution.detail.error_types_of_t;
 import beman.execution.detail.fwd_env;
+import beman.execution.detail.get_completion_domain;
+import beman.execution.detail.get_completion_scheduler;
 import beman.execution.detail.get_completion_signatures;
 import beman.execution.detail.get_env;
 import beman.execution.detail.impls_for;
@@ -49,6 +52,7 @@ import beman.execution.detail.sender_for;
 import beman.execution.detail.sender_in;
 import beman.execution.detail.set_error;
 import beman.execution.detail.set_stopped;
+import beman.execution.detail.set_value;
 import beman.execution.detail.start;
 #else
 #include <beman/execution/detail/as_tuple.hpp>
@@ -57,9 +61,12 @@ import beman.execution.detail.start;
 #include <beman/execution/detail/connect.hpp>
 #include <beman/execution/detail/decayed_tuple.hpp>
 #include <beman/execution/detail/default_impls.hpp>
+#include <beman/execution/detail/env.hpp>
 #include <beman/execution/detail/env_of_t.hpp>
 #include <beman/execution/detail/error_types_of_t.hpp>
 #include <beman/execution/detail/fwd_env.hpp>
+#include <beman/execution/detail/get_completion_domain.hpp>
+#include <beman/execution/detail/get_completion_scheduler.hpp>
 #include <beman/execution/detail/get_env.hpp>
 #include <beman/execution/detail/impls_for.hpp>
 #include <beman/execution/detail/join_env.hpp>
@@ -79,6 +86,7 @@ import beman.execution.detail.start;
 #include <beman/execution/detail/sender_in.hpp>
 #include <beman/execution/detail/set_error.hpp>
 #include <beman/execution/detail/set_stopped.hpp>
+#include <beman/execution/detail/set_value.hpp>
 #include <beman/execution/detail/start.hpp>
 #endif
 
@@ -103,13 +111,15 @@ struct continues_on_t {
     }
 
   private:
-    template <typename, typename>
+    template <typename, typename...>
     struct get_signatures;
+    template <typename Sender>
+    struct get_signatures<Sender> : get_signatures<Sender, ::beman::execution::env<>> {};
     template <typename Scheduler, typename Sender, typename Env>
     struct get_signatures<
         ::beman::execution::detail::basic_sender<::beman::execution::detail::continues_on_t, Scheduler, Sender>,
         Env> {
-        using scheduler_sender = decltype(::beman::execution::schedule(::std::declval<Scheduler>()));
+        using scheduler_sender = ::beman::execution::schedule_result_t<Scheduler>;
         template <typename... E>
         using as_set_error = ::beman::execution::completion_signatures<::beman::execution::set_error_t(E)...>;
         using type         = ::beman::execution::detail::meta::combine<
@@ -118,13 +128,54 @@ struct continues_on_t {
             ::beman::execution::completion_signatures<::beman::execution::set_error_t(::std::exception_ptr)>>;
     };
 
+    template <typename Scheduler, typename ChildAttrs>
+    struct attrs {
+        template <typename Tag, typename... Env>
+            requires requires(const Scheduler& scheduler, const Env&... env) {
+                ::beman::execution::get_completion_scheduler<Tag>(scheduler,
+                                                                  ::beman::execution::detail::fwd_env(env)...);
+            }
+        auto query(::beman::execution::get_completion_scheduler_t<Tag>, const Env&... env) const noexcept {
+            return ::beman::execution::get_completion_scheduler<Tag>(this->sch, env...);
+        }
+
+        template <typename Tag, typename... Env>
+            requires requires(const Scheduler& scheduler, const Env&... env) {
+                ::beman::execution::get_completion_domain<Tag>(scheduler, ::beman::execution::detail::fwd_env(env)...);
+            }
+        auto query(::beman::execution::get_completion_domain_t<Tag>, const Env&... env) const noexcept {
+            return ::beman::execution::get_completion_domain<Tag>(this->sch,
+                                                                  ::beman::execution::detail::fwd_env(env)...);
+        }
+
+        template <typename Q, typename... Args>
+            requires requires(const ChildAttrs& child_attrs, Q q, Args&&... args) {
+                child_attrs.query(q, ::std::forward<Args>(args)...);
+            }
+        auto query(Q q, Args&&... args) const noexcept {
+            return this->child_attrs.query(q, ::std::forward<Args>(args)...);
+        }
+
+        Scheduler  sch;
+        ChildAttrs child_attrs;
+    };
+
   public:
     template <typename Sender, typename... Env>
-    static consteval auto get_completion_signatures() {
+    static consteval auto get_completion_signatures() noexcept {
         return typename get_signatures<::std::remove_cvref_t<Sender>, Env...>::type{};
     }
 
     struct impls_for : ::beman::execution::detail::default_impls {
+        struct get_attrs_impl {
+            auto operator()(const auto& sch, const auto& child) const noexcept {
+                using Sch        = ::std::remove_cvref_t<decltype(sch)>;
+                using ChildAttrs = ::std::remove_cvref_t<decltype(::beman::execution::get_env(child))>;
+                return attrs<Sch, ChildAttrs>{sch, ::beman::execution::get_env(child)};
+            }
+        };
+        static constexpr auto get_attrs{get_attrs_impl{}};
+
         template <typename State>
         struct upstream_receiver {
             using receiver_concept = ::beman::execution::receiver_tag;
diff --git a/include/beman/execution/detail/get_completion_scheduler.hpp b/include/beman/execution/detail/get_completion_scheduler.hpp
index de5a67a3..cb7cba53 100644
--- a/include/beman/execution/detail/get_completion_scheduler.hpp
+++ b/include/beman/execution/detail/get_completion_scheduler.hpp
@@ -18,11 +18,13 @@ import beman.execution.detail.completion_tag;
 import beman.execution.detail.forwarding_query;
 import beman.execution.detail.scheduler;
 import beman.execution.detail.set_value;
+import beman.execution.detail.try_query;
 #else
 #include <beman/execution/detail/completion_tag.hpp>
 #include <beman/execution/detail/forwarding_query.hpp>
 #include <beman/execution/detail/scheduler.hpp>
 #include <beman/execution/detail/set_value.hpp>
+#include <beman/execution/detail/try_query.hpp>
 #endif
 
 // ----------------------------------------------------------------------------
@@ -38,7 +40,8 @@ template <typename Tag, typename Q, typename... E>
 concept compl_sched_recurse_queryable = requires {
     {
         ::beman::execution::detail::recurse_query(
-            ::std::declval<const Q&>().query(
+            ::beman::execution::detail::try_query(
+                ::std::declval<const Q&>(),
                 ::std::declval<::beman::execution::detail::get_completion_scheduler_t<Tag>>(),
                 ::std::declval<const E&>()...),
             ::std::declval<const E&>()...)
@@ -49,18 +52,18 @@ template <::beman::execution::detail::completion_tag Tag>
 struct get_completion_scheduler_t : ::beman::execution::forwarding_query_t {
     template <typename Q, typename... E>
         requires ::beman::execution::detail::compl_sched_recurse_queryable<Tag, Q, E...> ||
-                 (::beman::execution::scheduler<Q> && sizeof...(E) > 0)
+                 ::beman::execution::scheduler<Q>
     auto operator()(const Q& q, const E&... e) const noexcept;
 };
 
 template <typename Scheduler, typename... Envs>
 auto recurse_query(Scheduler sch, const Envs&... envs) noexcept {
     ::beman::execution::detail::get_completion_scheduler_t<::beman::execution::set_value_t> get_compl_sch{};
-    if constexpr (requires { ::std::as_const(sch).query(get_compl_sch, envs...); }) {
-        auto sch2 = ::std::as_const(sch).query(get_compl_sch, envs...);
+    if constexpr (requires { ::beman::execution::detail::try_query(sch, get_compl_sch, envs...); }) {
+        auto sch2 = ::beman::execution::detail::try_query(sch, get_compl_sch, envs...);
         if constexpr (::std::same_as<Scheduler, decltype(sch2)>) {
             while (sch != sch2) {
-                sch = ::std::exchange(sch2, ::std::as_const(sch2).query(get_compl_sch, envs...));
+                sch = ::std::exchange(sch2, ::beman::execution::detail::try_query(sch2, get_compl_sch, envs...));
             }
             return sch;
         } else {
@@ -74,12 +77,12 @@ auto recurse_query(Scheduler sch, const Envs&... envs) noexcept {
 template <::beman::execution::detail::completion_tag Tag>
 template <typename Q, typename... E>
     requires ::beman::execution::detail::compl_sched_recurse_queryable<Tag, Q, E...> ||
-             (::beman::execution::scheduler<Q> && sizeof...(E) > 0)
+             ::beman::execution::scheduler<Q>
 auto get_completion_scheduler_t<Tag>::operator()(const Q& q, const E&... e) const noexcept {
     if constexpr (::beman::execution::detail::compl_sched_recurse_queryable<Tag, Q, E...>) {
-        return ::beman::execution::detail::recurse_query(q.query(*this, e...), e...);
+        return ::beman::execution::detail::recurse_query(::beman::execution::detail::try_query(q, *this, e...), e...);
     } else {
-        static_assert(::beman::execution::scheduler<Q> && sizeof...(E) > 0);
+        static_assert(::beman::execution::scheduler<Q>);
         return q;
     }
 }
diff --git a/include/beman/execution/detail/get_completion_signatures.hpp b/include/beman/execution/detail/get_completion_signatures.hpp
index dcf513ce..9acc05cb 100644
--- a/include/beman/execution/detail/get_completion_signatures.hpp
+++ b/include/beman/execution/detail/get_completion_signatures.hpp
@@ -73,6 +73,15 @@ consteval auto get_completion_signatures() -> ::beman::execution::detail::valid_
                               ::std::remove_cvref_t<Sndr>::template get_completion_signatures<Sndr, E...>()>) {
                 return ::std::remove_cvref_t<Sndr>::template get_completion_signatures<Sndr, E...>();
             }
+        } else if constexpr (requires {
+                                 {
+                                     ::std::remove_cvref_t<Sndr>::get_completion_signatures()
+                                 } -> ::beman::execution::detail::valid_completion_signatures;
+                             }) {
+            if constexpr (::beman::execution::detail::is_constant<
+                              ::std::remove_cvref_t<Sndr>::get_completion_signatures()>) {
+                return ::std::remove_cvref_t<Sndr>::get_completion_signatures();
+            }
         }
     }};
     if constexpr (requires {
diff --git a/include/beman/execution/detail/let.hpp b/include/beman/execution/detail/let.hpp
index c40c3b14..97f8a14b 100644
--- a/include/beman/execution/detail/let.hpp
+++ b/include/beman/execution/detail/let.hpp
@@ -21,17 +21,19 @@ import beman.execution.detail.allocator_aware_move;
 import beman.execution.detail.basic_sender;
 import beman.execution.detail.call_result_t;
 import beman.execution.detail.completion_signatures;
-import beman.execution.detail.completion_signatures_for;
 import beman.execution.detail.completion_signatures_of_t;
 import beman.execution.detail.connect;
 import beman.execution.detail.decayed_tuple;
 import beman.execution.detail.default_impls;
+import beman.execution.detail.dependent_sender;
 import beman.execution.detail.emplace_from;
 import beman.execution.detail.env;
 import beman.execution.detail.env_of_t;
 import beman.execution.detail.forward_like;
 import beman.execution.detail.fwd_env;
+import beman.execution.detail.gather_signatures;
 import beman.execution.detail.get_env;
+import beman.execution.detail.get_completion_domain;
 import beman.execution.detail.get_completion_scheduler;
 import beman.execution.detail.get_completion_signatures;
 import beman.execution.detail.get_domain;
@@ -57,16 +59,18 @@ import beman.execution.detail.start;
 import beman.execution.detail.type_list;
 #else
 #include <beman/execution/detail/allocator_aware_move.hpp>
-#include <beman/execution/detail/completion_signatures_for.hpp>
 #include <beman/execution/detail/completion_signatures_of_t.hpp>
 #include <beman/execution/detail/connect.hpp>
 #include <beman/execution/detail/decayed_tuple.hpp>
 #include <beman/execution/detail/default_impls.hpp>
+#include <beman/execution/detail/dependent_sender.hpp>
 #include <beman/execution/detail/emplace_from.hpp>
 #include <beman/execution/detail/env.hpp>
 #include <beman/execution/detail/env_of_t.hpp>
 #include <beman/execution/detail/forward_like.hpp>
 #include <beman/execution/detail/fwd_env.hpp>
+#include <beman/execution/detail/gather_signatures.hpp>
+#include <beman/execution/detail/get_completion_domain.hpp>
 #include <beman/execution/detail/impls_for.hpp>
 #include <beman/execution/detail/join_env.hpp>
 #include <beman/execution/detail/make_env.hpp>
@@ -101,15 +105,32 @@ struct let_matching_completion : ::std::false_type {};
 template <typename Tag, typename... A>
 struct let_matching_completion<Tag, Tag(A...)> : ::std::true_type {};
 
-template <typename Child, bool, typename... Env>
-struct let_upstream_env_helper {
-    using type = decltype(::beman::execution::detail::join_env(::std::declval<Child>(), ::std::declval<Env>()...));
-};
-template <typename Child>
-struct let_upstream_env_helper<Child, false> {
-    using type = Child;
+template <typename, typename>
+struct get_successor_senders;
+
+template <typename Fun, typename... Args>
+struct get_successor_senders<Fun, ::beman::execution::detail::type_list<Args...>> {
+    using type = std::invoke_result_t<Fun, Args...>;
 };
 
+template <typename, typename>
+struct non_dependent_successor_helper;
+
+template <typename Fun, typename... TypeLists>
+struct non_dependent_successor_helper<Fun, ::beman::execution::detail::type_list<TypeLists...>>
+    : std::bool_constant<(... &&
+                          !::beman::execution::dependent_sender<
+                              typename ::beman::execution::detail::get_successor_senders<Fun, TypeLists>::type>)> {};
+
+template <typename Completion, typename Child, typename Fun>
+struct non_dependent_successor
+    : ::beman::execution::detail::non_dependent_successor_helper<
+          Fun,
+          ::beman::execution::detail::gather_signatures<Completion,
+                                                        ::beman::execution::completion_signatures_of_t<Child>,
+                                                        ::beman::execution::detail::type_list,
+                                                        ::beman::execution::detail::type_list>> {};
+
 template <typename Completion>
 struct let_t {
     template <::beman::execution::detail::movable_value Fun>
@@ -121,37 +142,48 @@ struct let_t {
         return ::beman::execution::detail::make_sender(*this, ::std::forward<Fun>(fun), std::forward<Sender>(sender));
     }
 
-    template <typename Sender>
-    static auto env(Sender&& sender) {
+    template <typename Sender, typename Env>
+    static auto let_env(const Sender& sender, const Env& e) {
         if constexpr (requires {
                           ::beman::execution::detail::sched_env(
                               ::beman::execution::get_completion_scheduler<Completion>(
-                                  ::beman::execution::get_env(sender)));
-                      })
-            return ::beman::execution::detail::sched_env(
-                ::beman::execution::get_completion_scheduler<Completion>(::beman::execution::get_env(sender)));
-        else if constexpr (requires {
-                               ::beman::execution::detail::make_env(
-                                   ::beman::execution::get_domain,
-                                   ::beman::execution::get_domain(::beman::execution::get_env(sender)));
-                           })
+                                  ::beman::execution::get_env(sender), ::beman::execution::detail::fwd_env(e)));
+                      }) {
+            return ::beman::execution::detail::sched_env(::beman::execution::get_completion_scheduler<Completion>(
+                ::beman::execution::get_env(sender), ::beman::execution::detail::fwd_env(e)));
+        } else if constexpr (requires {
+                                 ::beman::execution::detail::make_env(
+                                     ::beman::execution::get_domain,
+                                     ::beman::execution::get_completion_domain<Completion>(
+                                         ::beman::execution::get_env(sender), ::beman::execution::detail::fwd_env(e)));
+                             })
             return ::beman::execution::detail::make_env(
-                ::beman::execution::get_domain, ::beman::execution::get_domain(::beman::execution::get_env(sender)));
-        else
+                ::beman::execution::get_domain,
+                ::beman::execution::get_completion_domain<Completion>(::beman::execution::get_env(sender),
+                                                                      ::beman::execution::detail::fwd_env(e)));
+        else {
             return ::beman::execution::env<>{};
-    }
-    template <typename Sender, typename Env>
-    static auto join_env(Sender&& sender, Env&& e) -> decltype(auto) {
-        return ::beman::execution::detail::join_env(env(sender), ::beman::execution::detail::fwd_env(e));
+        }
     }
 
+    template <typename Sndr, typename Env>
+    using let_env_t = decltype(let_env(::std::declval<Sndr>(), ::std::declval<Env>()));
+
   private:
     template <typename, typename...>
     struct get_signatures;
-    template <typename Comp, typename Fun, typename Child, typename... Env>
+
+    template <typename Comp, typename Fun, typename Child>
+        requires ::beman::execution::detail::non_dependent_successor<Completion, Child, Fun>::value
+    struct get_signatures<
+        ::beman::execution::detail::basic_sender<::beman::execution::detail::let_t<Comp>, Fun, Child>>
+        : get_signatures<::beman::execution::detail::basic_sender<::beman::execution::detail::let_t<Comp>, Fun, Child>,
+                         ::beman::execution::env<>> {};
+
+    template <typename Comp, typename Fun, typename Child, typename Env>
     struct get_signatures<
         ::beman::execution::detail::basic_sender<::beman::execution::detail::let_t<Comp>, Fun, Child>,
-        Env...> {
+        Env> {
         template <typename T>
         using other_completion = let_other_completion<Comp, T>;
         template <typename T>
@@ -163,38 +195,44 @@ struct let_t {
         struct apply_decayed<C(A...)> {
             using sender_type = ::beman::execution::detail::call_result_t<Fun, ::std::decay_t<A>...>;
             using completions = ::std::conditional_t<
-                noexcept(::std::declval<Fun>()(std::declval<::std::decay_t<A>>()...)),
+                noexcept(::std::declval<Fun>()(::std::declval<::std::decay_t<A>>()...)),
                 ::beman::execution::completion_signatures<>,
                 ::beman::execution::completion_signatures<::beman::execution::set_error_t(::std::exception_ptr)>>;
         };
+
+        using successor_env =
+            ::beman::execution::detail::join_env<let_env_t<Child, Env>, ::beman::execution::detail::fwd_env<Env>>;
+
         template <typename>
         struct get_completions;
         template <template <typename...> class L, typename... C>
         struct get_completions<L<C...>> {
             using type = ::beman::execution::detail::meta::unique<::beman::execution::detail::meta::combine<
                 ::beman::execution::completion_signatures<>,
-                ::beman::execution::completion_signatures_of_t<typename apply_decayed<C>::sender_type, Env...>...,
+                ::beman::execution::completion_signatures_of_t<typename apply_decayed<C>::sender_type,
+                                                               successor_env>...,
                 typename apply_decayed<C>::completions...>>;
         };
 
-        using upstream_env         = typename let_upstream_env_helper<Child, 0 < sizeof...(Env), Env...>::type;
-        using upstream_completions = decltype(::beman::execution::get_completion_signatures<Child, upstream_env>());
+        using upstream_completions = ::beman::execution::completion_signatures_of_t<Child, Env>;
         using other_completions    = ::beman::execution::detail::meta::filter<other_completion, upstream_completions>;
         using matching_completions =
             ::beman::execution::detail::meta::filter<matching_completion, upstream_completions>;
         using type = ::beman::execution::detail::meta::unique<
             ::beman::execution::detail::meta::combine<typename get_completions<matching_completions>::type,
                                                       other_completions>>;
+
+        static consteval auto get() noexcept { return type{}; }
     };
 
   public:
     template <typename Sender, typename... Env>
+        requires requires { get_signatures<std::remove_cvref_t<Sender>, Env...>::get(); }
     static consteval auto get_completion_signatures() {
-        return typename get_signatures<std::remove_cvref_t<Sender>, Env...>::type{};
+        return get_signatures<std::remove_cvref_t<Sender>, Env...>::get();
     }
 
     struct impls_for : ::beman::execution::detail::default_impls {
-
         template <typename Receiver, typename Env>
         struct let_receiver {
             using receiver_concept = ::beman::execution::receiver_tag;
@@ -243,7 +281,7 @@ struct let_t {
 
             using fun_t   = ::std::remove_cvref_t<decltype(fun)>;
             using child_t = ::std::remove_cvref_t<decltype(child)>;
-            using env_t   = decltype(::beman::execution::detail::let_t<Completion>::env(child));
+            using env_t   = let_env_t<child_t, ::beman::execution::env_of_t<Receiver>>;
             using sigs_t =
                 ::beman::execution::completion_signatures_of_t<child_t, ::beman::execution::env_of_t<Receiver>>;
             using comp_sigs_t = ::beman::execution::detail::meta::filter<filter_pred, sigs_t>;
@@ -263,11 +301,12 @@ struct let_t {
                 args_t args;
                 ops_t  ops2;
             };
-            return state_t{beman::execution::detail::allocator_aware_move(
-                               ::beman::execution::detail::forward_like<Sender>(fun), receiver),
-                           ::beman::execution::detail::let_t<Completion>::env(child),
-                           {},
-                           {}};
+            return state_t{
+                beman::execution::detail::allocator_aware_move(::beman::execution::detail::forward_like<Sender>(fun),
+                                                               receiver),
+                ::beman::execution::detail::let_t<Completion>::let_env(child, ::beman::execution::get_env(receiver)),
+                {},
+                {}};
         }};
         template <typename Receiver, typename... Args>
         static auto let_bind(auto& state, Receiver& receiver, Args&&... args) noexcept(
diff --git a/include/beman/execution/detail/starts_on.hpp b/include/beman/execution/detail/starts_on.hpp
index 1719be47..eb31e8b0 100644
--- a/include/beman/execution/detail/starts_on.hpp
+++ b/include/beman/execution/detail/starts_on.hpp
@@ -9,99 +9,152 @@
 import std;
 #else
 #include <concepts>
+#include <type_traits>
 #include <utility>
 #endif
 #ifdef BEMAN_HAS_MODULES
+import beman.execution.detail.basic_sender;
+import beman.execution.detail.completion_signatures;
+import beman.execution.detail.completion_signatures_of_t;
 import beman.execution.detail.continues_on;
-import beman.execution.detail.default_domain;
 import beman.execution.detail.default_impls;
+import beman.execution.detail.env;
+import beman.execution.detail.error_types_of_t;
 import beman.execution.detail.forward_like;
 import beman.execution.detail.fwd_env;
 import beman.execution.detail.get_completion_domain;
-import beman.execution.detail.get_domain;
+import beman.execution.detail.get_completion_scheduler;
 import beman.execution.detail.get_env;
 import beman.execution.detail.join_env;
 import beman.execution.detail.just;
 import beman.execution.detail.let;
 import beman.execution.detail.make_sender;
+import beman.execution.detail.meta.combine;
 import beman.execution.detail.query_with_default;
 import beman.execution.detail.sched_env;
-import beman.execution.detail.schedule;
+import beman.execution.detail.schedule_result_t;
 import beman.execution.detail.scheduler;
 import beman.execution.detail.sender;
 import beman.execution.detail.sender_for;
+import beman.execution.detail.sends_stopped;
+import beman.execution.detail.set_error;
+import beman.execution.detail.set_stopped;
 import beman.execution.detail.set_value;
-import beman.execution.detail.transform_sender;
+import beman.execution.detail.write_env;
 #else
+#include <beman/execution/detail/basic_sender.hpp>
+#include <beman/execution/detail/completion_signatures.hpp>
+#include <beman/execution/detail/completion_signatures_of_t.hpp>
 #include <beman/execution/detail/continues_on.hpp>
-#include <beman/execution/detail/default_domain.hpp>
 #include <beman/execution/detail/default_impls.hpp>
+#include <beman/execution/detail/env.hpp>
+#include <beman/execution/detail/error_types_of_t.hpp>
 #include <beman/execution/detail/forward_like.hpp>
 #include <beman/execution/detail/fwd_env.hpp>
 #include <beman/execution/detail/get_completion_domain.hpp>
-#include <beman/execution/detail/get_domain.hpp>
+#include <beman/execution/detail/get_completion_scheduler.hpp>
 #include <beman/execution/detail/get_env.hpp>
-#include <beman/execution/detail/continues_on.hpp>
 #include <beman/execution/detail/join_env.hpp>
 #include <beman/execution/detail/just.hpp>
 #include <beman/execution/detail/let.hpp>
 #include <beman/execution/detail/make_sender.hpp>
-#include <beman/execution/detail/query_with_default.hpp>
+#include <beman/execution/detail/meta_combine.hpp>
 #include <beman/execution/detail/sched_env.hpp>
-#include <beman/execution/detail/schedule.hpp>
+#include <beman/execution/detail/schedule_result_t.hpp>
 #include <beman/execution/detail/scheduler.hpp>
 #include <beman/execution/detail/sender_for.hpp>
+#include <beman/execution/detail/sends_stopped.hpp>
+#include <beman/execution/detail/set_error.hpp>
+#include <beman/execution/detail/set_stopped.hpp>
 #include <beman/execution/detail/set_value.hpp>
-#include <beman/execution/detail/transform_sender.hpp>
+#include <beman/execution/detail/write_env.hpp>
 #endif
 
 // ----------------------------------------------------------------------------
 
 namespace beman::execution::detail {
-
-template <typename Scheduler, typename ChildEnv>
-struct starts_on_attrs_t {
-    Scheduler sch;
-    ChildEnv  child_env;
-
-    template <typename Tag, typename Env>
-    auto query(::beman::execution::get_completion_domain_t<Tag>, const Env& rcvr_env) const noexcept {
-        auto env_for_child = ::beman::execution::detail::join_env(::beman::execution::detail::sched_env(sch),
-                                                                  ::beman::execution::detail::fwd_env(rcvr_env));
-        if constexpr (requires { ::beman::execution::get_completion_domain<Tag>(child_env, env_for_child); }) {
-            return ::beman::execution::get_completion_domain<Tag>(child_env, env_for_child);
-        } else {
-            return ::beman::execution::default_domain{};
-        }
-    }
-
-    template <typename Q, typename... Args>
-        requires requires { ::std::as_const(child_env).query(::std::declval<Q>(), ::std::declval<Args>()...); }
-    auto query(Q q, Args&&... args) const noexcept {
-        return ::std::as_const(child_env).query(q, ::std::forward<Args>(args)...);
-    }
-};
-
 struct starts_on_t {
     template <::beman::execution::detail::sender_for<::beman::execution::detail::starts_on_t> Sender, typename Env>
     auto transform_sender(::beman::execution::set_value_t, Sender&& sender, const Env&) const noexcept {
-        auto&& scheduler{sender.template get<1>()};
-        auto&& new_sender{sender.template get<2>()};
+        auto&&         sched{sender.template get<1>()};
+        auto&&         child{sender.template get<2>()};
+        constexpr bool is_nothrow = ::std::is_nothrow_move_constructible_v<::std::remove_cvref_t<decltype(child)>>;
         return ::beman::execution::let_value(
-            ::beman::execution::continues_on(::beman::execution::just(), scheduler),
-            [new_sender = ::beman::execution::detail::forward_like<Sender>(new_sender)]() mutable noexcept(
-                ::std::is_nothrow_move_constructible_v<::std::remove_cvref_t<Sender>>) {
-                return ::std::move(new_sender);
+            ::beman::execution::continues_on(::beman::execution::just(), sched),
+            [child_ = ::beman::execution::detail::forward_like<Sender>(child)]() mutable noexcept(is_nothrow) {
+                return ::std::move(child_);
             });
     }
 
+  private:
+    template <typename, typename...>
+    struct get_signatures;
+    template <typename Sender>
+    struct get_signatures<Sender> : get_signatures<Sender, ::beman::execution::env<>> {};
+    template <typename Scheduler, typename Child, typename Env>
+    struct get_signatures<
+        ::beman::execution::detail::basic_sender<::beman::execution::detail::starts_on_t, Scheduler, Child>,
+        Env> {
+        using scheduler_sender = ::beman::execution::schedule_result_t<Scheduler>;
+        using child_env        = decltype(::beman::execution::detail::join_env(
+            ::beman::execution::detail::sched_env(::std::declval<Scheduler>()),
+            ::beman::execution::detail::fwd_env(::std::declval<Env>())));
+
+        template <typename... E>
+        using as_set_error = ::beman::execution::completion_signatures<::beman::execution::set_error_t(E)...>;
+
+        using value_and_error_types = ::beman::execution::detail::meta::combine<
+            ::beman::execution::completion_signatures_of_t<Child, child_env>,
+            ::beman::execution::error_types_of_t<scheduler_sender, Env, as_set_error>>;
+        using stopped_types =
+            ::std::conditional_t<::beman::execution::sends_stopped<scheduler_sender, Env>,
+                                 ::beman::execution::completion_signatures<::beman::execution::set_stopped_t()>,
+                                 ::beman::execution::completion_signatures<>>;
+        using type = ::beman::execution::detail::meta::combine<value_and_error_types, stopped_types>;
+    };
+
+    template <typename Scheduler, typename ChildAttrs>
+    struct attrs {
+        template <typename Env>
+        auto wrap_env(const Env& env) const noexcept {
+            return ::beman::execution::detail::join_env(::beman::execution::detail::sched_env(this->sch), env);
+        }
+
+        template <typename Tag, typename... Env>
+        auto query(::beman::execution::get_completion_scheduler_t<Tag>, const Env&... env) const noexcept {
+            if constexpr (requires {
+                              ::beman::execution::get_completion_scheduler<Tag>(this->child_attrs,
+                                                                                this->wrap_env(env)...);
+                          }) {
+                return ::beman::execution::get_completion_scheduler<Tag>(this->child_attrs, this->wrap_env(env)...);
+            } else {
+                return this->sch;
+            }
+        }
+
+        template <typename Tag, typename... Env>
+        static auto query(::beman::execution::get_completion_domain_t<Tag>, const Env&...) noexcept
+            -> decltype(::beman::execution::get_completion_domain<Tag>(
+                ::std::declval<ChildAttrs>(), std::declval<attrs>().wrap_env(::std::declval<Env>())...)) {
+            return {};
+        }
+
+        Scheduler  sch;
+        ChildAttrs child_attrs;
+    };
+
+  public:
+    template <typename Sender, typename... Env>
+    static consteval auto get_completion_signatures() noexcept {
+        return typename get_signatures<::std::remove_cvref_t<Sender>, Env...>::type{};
+    }
+
     struct impls_for : ::beman::execution::detail::default_impls {
         struct get_attrs_impl {
             auto operator()(const auto& sch, const auto& child) const noexcept {
                 using Sch      = ::std::remove_cvref_t<decltype(sch)>;
                 using ChildEnv = ::std::remove_cvref_t<decltype(::beman::execution::get_env(child))>;
-                return ::beman::execution::detail::starts_on_attrs_t<Sch, ChildEnv>{
-                    sch, ::beman::execution::get_env(child)};
+                return attrs<Sch, ChildEnv>{sch, ::beman::execution::get_env(child)};
             }
         };
         static constexpr auto get_attrs{get_attrs_impl{}};
diff --git a/include/beman/execution/detail/unstoppable_scheduler.hpp b/include/beman/execution/detail/unstoppable_scheduler.hpp
new file mode 100644
index 00000000..5f8a8b70
--- /dev/null
+++ b/include/beman/execution/detail/unstoppable_scheduler.hpp
@@ -0,0 +1,46 @@
+// include/beman/execution/detail/unstoppable_scheduler.hpp          -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef INCLUDED_INCLUDE_BEMAN_EXECUTION_DETAIL_UNSTOPPABLE_SCHEDULER
+#define INCLUDED_INCLUDE_BEMAN_EXECUTION_DETAIL_UNSTOPPABLE_SCHEDULER
+
+#ifdef BEMAN_HAS_IMPORT_STD
+import std;
+#else
+#include <type_traits>
+#include <utility>
+#endif
+#ifdef BEMAN_HAS_MODULES
+import beman.execution.detail.schedule;
+import beman.execution.detail.scheduler;
+import beman.execution.detail.unstoppable;
+#else
+#include <beman/execution/detail/schedule.hpp>
+#include <beman/execution/detail/scheduler.hpp>
+#include <beman/execution/detail/unstoppable.hpp>
+#endif
+
+// ----------------------------------------------------------------------------
+
+namespace beman::execution::detail {
+template <typename Sched>
+struct unstoppable_scheduler {
+    using scheduler_concept = typename Sched::scheduler_concept;
+
+    template <typename Q, typename... Args>
+        requires requires { ::std::declval<Sched>().query(::std::declval<const Q&>(), ::std::declval<Args>()...); }
+    auto query(const Q& q, Args&&... args) const noexcept -> decltype(auto) {
+        return sched.query(q, ::std::forward<Args>(args)...);
+    }
+
+    auto schedule() const noexcept(std::is_nothrow_invocable_v<::beman::execution::schedule_t, Sched>) {
+        return ::beman::execution::unstoppable(::beman::execution::schedule(sched));
+    }
+
+    friend auto operator==(const unstoppable_scheduler& lhs, const unstoppable_scheduler& rhs) -> bool = default;
+
+    Sched sched;
+};
+} // namespace beman::execution::detail
+
+#endif // INCLUDED_INCLUDE_BEMAN_EXECUTION_DETAIL_UNSTOPPABLE_SCHEDULER
diff --git a/include/beman/execution/detail/when_all.hpp b/include/beman/execution/detail/when_all.hpp
index 37564da5..c7323415 100644
--- a/include/beman/execution/detail/when_all.hpp
+++ b/include/beman/execution/detail/when_all.hpp
@@ -22,6 +22,8 @@ import beman.execution.detail.basic_sender;
 import beman.execution.detail.completion_signatures;
 import beman.execution.detail.completion_signatures_for;
 import beman.execution.detail.completion_signatures_of_t;
+import beman.execution.detail.common_domain;
+import beman.execution.detail.compl_domain;
 import beman.execution.detail.decayed_tuple;
 import beman.execution.detail.decayed_type_list;
 import beman.execution.detail.default_domain;
@@ -32,6 +34,7 @@ import beman.execution.detail.env;
 import beman.execution.detail.env_of_t;
 import beman.execution.detail.error_types_of_t;
 import beman.execution.detail.get_env;
+import beman.execution.detail.get_completion_domain;
 import beman.execution.detail.get_domain;
 import beman.execution.detail.get_stop_token;
 import beman.execution.detail.impls_for;
@@ -61,6 +64,8 @@ import beman.execution.detail.transform_sender;
 import beman.execution.detail.type_list;
 import beman.execution.detail.value_types_of_t;
 #else
+#include <beman/execution/detail/compl_domain.hpp>
+#include <beman/execution/detail/common_domain.hpp>
 #include <beman/execution/detail/completion_signatures_of_t.hpp>
 #include <beman/execution/detail/decayed_tuple.hpp>
 #include <beman/execution/detail/decayed_type_list.hpp>
@@ -71,6 +76,7 @@ import beman.execution.detail.value_types_of_t;
 #include <beman/execution/detail/env.hpp>
 #include <beman/execution/detail/env_of_t.hpp>
 #include <beman/execution/detail/error_types_of_t.hpp>
+#include <beman/execution/detail/get_completion_domain.hpp>
 #include <beman/execution/detail/get_domain.hpp>
 #include <beman/execution/detail/get_stop_token.hpp>
 #include <beman/execution/detail/impls_for.hpp>
@@ -170,6 +176,48 @@ struct when_all_t {
         using type = ::beman::execution::detail::meta::combine<value_types, error_types, stopped_types>;
     };
 
+    template <typename... Sender>
+    struct attrs {
+        template <typename Tag, typename... Env>
+        using child_domain_t = ::beman::execution::detail::common_domain_t<
+            ::beman::execution::detail::compl_domain_of_t<Tag, Sender, Env...>...>;
+
+        template <typename... Env>
+            requires requires { typename child_domain_t<::beman::execution::set_value_t, Env...>; }
+        static auto query(::beman::execution::get_completion_domain_t<::beman::execution::set_value_t>,
+                          const Env&...) noexcept -> child_domain_t<::beman::execution::set_value_t, Env...> {
+            return {};
+        }
+
+        template <typename... Env>
+            requires requires {
+                typename ::beman::execution::detail::common_domain_t<
+                    child_domain_t<::beman::execution::set_value_t, Env...>,
+                    child_domain_t<::beman::execution::set_error_t, Env...>,
+                    child_domain_t<::beman::execution::set_stopped_t, Env...>>;
+            }
+        static auto query(::beman::execution::get_completion_domain_t<::beman::execution::set_error_t>,
+                          const Env&...) noexcept
+            -> ::beman::execution::detail::common_domain_t<child_domain_t<::beman::execution::set_value_t, Env...>,
+                                                           child_domain_t<::beman::execution::set_error_t, Env...>,
+                                                           child_domain_t<::beman::execution::set_stopped_t, Env...>> {
+            return {};
+        }
+
+        template <typename... Env>
+            requires requires {
+                typename ::beman::execution::detail::common_domain_t<
+                    child_domain_t<::beman::execution::set_value_t, Env...>,
+                    child_domain_t<::beman::execution::set_stopped_t, Env...>>;
+            }
+        static auto query(::beman::execution::get_completion_domain_t<::beman::execution::set_stopped_t>,
+                          const Env&...) noexcept
+            -> ::beman::execution::detail::common_domain_t<child_domain_t<::beman::execution::set_value_t, Env...>,
+                                                           child_domain_t<::beman::execution::set_stopped_t, Env...>> {
+            return {};
+        }
+    };
+
   public:
     template <typename Sender, typename... Env>
     static consteval auto get_completion_signatures() {
@@ -178,9 +226,13 @@ struct when_all_t {
 
     struct impls_for : ::beman::execution::detail::default_impls {
         struct get_attrs_impl {
-            auto operator()(auto&&, auto&&...) const { return ::beman::execution::env<>{}; }
+            template <typename... Children>
+            auto operator()(const auto&, const Children&...) const noexcept {
+                return attrs<Children...>{};
+            }
         };
         static constexpr auto get_attrs{get_attrs_impl{}};
+
         struct get_env_impl {
             template <typename State, typename Receiver>
             auto operator()(auto&&, State& state, const Receiver& receiver) const noexcept {
diff --git a/src/beman/execution/CMakeLists.txt b/src/beman/execution/CMakeLists.txt
index 5970aec7..e3cbe916 100644
--- a/src/beman/execution/CMakeLists.txt
+++ b/src/beman/execution/CMakeLists.txt
@@ -209,6 +209,7 @@ target_sources(
                 ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/type_list.hpp
                 ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/unspecified_promise.hpp
                 ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/unstoppable.hpp
+                ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/unstoppable_scheduler.hpp
                 ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/unstoppable_token.hpp
                 ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/unreachable.hpp
                 ${PROJECT_SOURCE_DIR}/include/beman/execution/detail/valid_completion_for.hpp
@@ -408,6 +409,7 @@ if(BEMAN_USE_MODULES)
                     type_list.cppm
                     unspecified_promise.cppm
                     unstoppable.cppm
+                    unstoppable_scheduler.cppm
                     unstoppable_token.cppm
                     unreachable.cppm
                     valid_completion_for.cppm
diff --git a/src/beman/execution/unstoppable_scheduler.cppm b/src/beman/execution/unstoppable_scheduler.cppm
new file mode 100644
index 00000000..ce87c0d4
--- /dev/null
+++ b/src/beman/execution/unstoppable_scheduler.cppm
@@ -0,0 +1,11 @@
+module;
+// src/beman/execution/unstoppable_scheduler.cppm                       -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <beman/execution/detail/unstoppable_scheduler.hpp>
+
+export module beman.execution.detail.unstoppable_scheduler;
+
+namespace beman::execution::detail {
+export using beman::execution::detail::unstoppable_scheduler;
+} // namespace beman::execution::detail
diff --git a/tests/beman/execution/CMakeLists.txt b/tests/beman/execution/CMakeLists.txt
index 29b11054..3dbfbc33 100644
--- a/tests/beman/execution/CMakeLists.txt
+++ b/tests/beman/execution/CMakeLists.txt
@@ -16,6 +16,7 @@ list(
     exec-bulk.test
     exec-connect.test
     exec-continues-on.test
+    exec-dependent-sender.test
     exec-domain-default.test
     exec-env.test
     exec-fwd-env.test
@@ -28,6 +29,7 @@ list(
     exec-get-domain.test
     exec-get-env.test
     exec-inline-scheduler.test
+    exec-get-start-scheduler.test
     exec-get-scheduler.test
     exec-get-stop-token.test
     exec-into-variant.test
diff --git a/tests/beman/execution/exec-continues-on.test.cpp b/tests/beman/execution/exec-continues-on.test.cpp
index c6d1ba01..ddfb39d3 100644
--- a/tests/beman/execution/exec-continues-on.test.cpp
+++ b/tests/beman/execution/exec-continues-on.test.cpp
@@ -84,6 +84,9 @@ auto test_use(Scheduler&& scheduler, Sender&& sender) {
     auto s{test_std::continues_on(::std::forward<Sender>(sender), ::std::forward<Scheduler>(scheduler))};
 
     static_assert(test_std::sender<decltype(s)>);
+    static_assert(
+        std::same_as<decltype(test_std::get_completion_scheduler<test_std::set_value_t>(test_std::get_env(s))),
+                     std::remove_cvref_t<Scheduler>>);
     //-dk:TODO test_std::sync_wait(std::move(s));
 }
 } // namespace
diff --git a/tests/beman/execution/exec-dependent-sender.test.cpp b/tests/beman/execution/exec-dependent-sender.test.cpp
new file mode 100644
index 00000000..d5ad7e7b
--- /dev/null
+++ b/tests/beman/execution/exec-dependent-sender.test.cpp
@@ -0,0 +1,29 @@
+// src/beman/execution/tests/exec-dependent-sender.test.cpp            -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <concepts>
+#include <test/execution.hpp>
+#ifdef BEMAN_HAS_MODULES
+import beman.execution;
+#else
+#include <beman/execution/detail/dependent_sender.hpp>
+#include <beman/execution/detail/just.hpp>
+#include <beman/execution/detail/let.hpp>
+#include <beman/execution/detail/read_env.hpp>
+#include <beman/execution/detail/then.hpp>
+#endif
+
+TEST(exec_dependent_sender) {
+    static_assert(test_std::dependent_sender<decltype(test_std::read_env(test_std::get_scheduler))>);
+    static_assert(test_std::dependent_sender<decltype(test_std::let_value(
+                      test_std::just(), []() noexcept { return test_std::read_env(test_std::get_scheduler); }))>);
+    static_assert(
+        test_std::dependent_sender<decltype(test_std::let_value(
+            test_std::read_env(test_std::get_scheduler), [](auto sched) noexcept { return test_std::just(sched); }))>);
+    static_assert(test_std::dependent_sender<decltype(test_std::read_env(test_std::get_scheduler) |
+                                                      test_std::then([](auto sched) noexcept {}))>);
+    static_assert(test_std::dependent_sender<decltype(test_std::let_value(
+                                                          test_std::read_env(test_std::get_scheduler),
+                                                          [](auto sched) noexcept { return test_std::just(sched); }) |
+                                                      test_std::then([](auto sched) noexcept {}))>);
+}
diff --git a/tests/beman/execution/exec-get-start-scheduler.test.cpp b/tests/beman/execution/exec-get-start-scheduler.test.cpp
new file mode 100644
index 00000000..db27bc84
--- /dev/null
+++ b/tests/beman/execution/exec-get-start-scheduler.test.cpp
@@ -0,0 +1,98 @@
+// src/beman/execution/tests/exec-get-start-scheduler.test.cpp          -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <concepts>
+#include <iostream>
+#include <test/execution.hpp>
+#ifdef BEMAN_HAS_MODULES
+import beman.execution;
+#else
+#include <beman/execution/detail/get_start_scheduler.hpp>
+#include <beman/execution/detail/inline_scheduler.hpp>
+#include <beman/execution/detail/let.hpp>
+#include <beman/execution/detail/read_env.hpp>
+#include <beman/execution/detail/then.hpp>
+#include <beman/execution/detail/run_loop.hpp>
+#include <beman/execution/detail/starts_on.hpp>
+#include <beman/execution/detail/sync_wait.hpp>
+#endif
+
+// ----------------------------------------------------------------------------
+
+namespace {
+struct receiver {
+    using receiver_concept = test_std::receiver_tag;
+    auto set_error(auto&&) && noexcept -> void {}
+    auto set_stopped() && noexcept -> void {}
+    auto set_value(auto&&...) && noexcept -> void {}
+};
+
+struct test_sched_sender;
+struct test_sched_env;
+
+struct test_scheduler {
+    using scheduler_concept = test_std::scheduler_tag;
+    auto schedule() const -> test_sched_sender;
+    auto operator==(const test_scheduler&) const -> bool = default;
+    int  scheduler_id                                    = 0;
+};
+
+template <typename Rcvr>
+struct test_sched_state {
+    using operation_state_concept = test_std::operation_state_tag;
+    auto start() noexcept { test_std::set_value(std::move(rcvr)); }
+    Rcvr rcvr;
+};
+
+struct test_sched_env {
+    auto query(test_std::get_completion_scheduler_t<test_std::set_value_t>) const noexcept {
+        return test_scheduler{scheduler_id};
+    }
+    int scheduler_id = 0;
+};
+
+struct test_sched_sender {
+    using sender_concept = test_std::sender_tag;
+    template <typename, typename...>
+    static consteval auto get_completion_signatures() {
+        return test_std::completion_signatures<test_std::set_value_t()>();
+    }
+    template <typename Rcvr>
+    auto connect(Rcvr rcvr) const {
+        return test_sched_state{std::move(rcvr)};
+    }
+    auto get_env() const noexcept { return test_sched_env{scheduler_id}; }
+
+    int scheduler_id = 0;
+};
+
+auto test_scheduler::schedule() const -> test_sched_sender { return {scheduler_id}; }
+
+} // namespace
+
+TEST(exec_get_start_scheduler) {
+    {
+        test_scheduler sched{42};
+        auto sndr = test_std::schedule(sched) |
+                    test_std::let_value([]() noexcept { return test_std::read_env(test_std::get_start_scheduler); }) |
+                    test_std::then([](test_scheduler sched) noexcept { ASSERT(sched == test_scheduler{42}); });
+        test_std::sync_wait(std::move(sndr));
+    }
+    {
+        test_std::sync_wait(
+            test_std::schedule(test_std::inline_scheduler{}) |
+            test_std::let_value([]() noexcept { return test_std::read_env(test_std::get_start_scheduler); }) |
+            test_std::then([](auto sched) noexcept {
+                // `sched` is the scheduler of the run_loop inside sync_wait
+                static_assert(
+                    std::same_as<decltype(sched), decltype(std::declval<test_std::run_loop>().get_scheduler())>);
+            }));
+    }
+    {
+        static_assert(test_std::scheduler<test_scheduler>);
+        auto sched = test_scheduler{114514};
+        auto [start_sched] =
+            test_std::sync_wait(test_std::starts_on(sched, test_std::read_env(test_std::get_start_scheduler))).value();
+        ASSERT(start_sched == sched);
+    }
+}
diff --git a/tests/beman/execution/exec-starts-on.test.cpp b/tests/beman/execution/exec-starts-on.test.cpp
index e34265fe..a11d2373 100644
--- a/tests/beman/execution/exec-starts-on.test.cpp
+++ b/tests/beman/execution/exec-starts-on.test.cpp
@@ -81,6 +81,9 @@ auto test_use(Scheduler&& scheduler, Sender&& sender) -> void {
     test_std::sync_wait(std::move(s));
 }
 
+template <typename Env>
+concept has_start_scheduler_query = requires(const Env& env) { env.query(test_std::get_start_scheduler); };
+
 auto test_starts_on_completions() {
     test_std::sync_wait(test::completion_test(test_std::starts_on(test_std::inline_scheduler(), test_std::just())));
     test_std::sync_wait(test::completion_test(test_std::just() | test_std::then([]() noexcept {})));
@@ -95,6 +98,23 @@ auto test_starts_on_completions() {
     test_std::sync_wait(test::completion_test(
         test_std::starts_on(test_std::inline_scheduler(), test_std::just() | test_std::then([]() noexcept {}))));
 }
+
+auto test_starts_on_start_scheduler() {
+    auto [sched] =
+        test_std::sync_wait(test_std::starts_on(scheduler{}, test_std::read_env(test_std::get_start_scheduler)))
+            .value();
+    static_assert(std::same_as<decltype(sched), scheduler>);
+}
+
+auto test_starts_on_attrs() {
+    using starts_on_sender = decltype(test_std::starts_on(scheduler{}, sender{}));
+    using attrs            = decltype(test_std::get_env(std::declval<const starts_on_sender&>()));
+
+    static_assert(not has_start_scheduler_query<attrs>);
+    static_assert(
+        std::same_as<decltype(test_std::get_completion_scheduler<test_std::set_value_t>(std::declval<const attrs&>())),
+                     scheduler>);
+}
 } // namespace
 
 TEST(exec_starts_on) {
@@ -111,4 +131,6 @@ TEST(exec_starts_on) {
 
     test_use(scheduler{}, sender{});
     test_starts_on_completions();
+    test_starts_on_attrs();
+    test_starts_on_start_scheduler();
 }
diff --git a/tests/beman/execution/exec-when-all.test.cpp b/tests/beman/execution/exec-when-all.test.cpp
index 2c3672b0..3ccf01de 100644
--- a/tests/beman/execution/exec-when-all.test.cpp
+++ b/tests/beman/execution/exec-when-all.test.cpp
@@ -47,6 +47,20 @@ struct domain_sender {
     auto get_env() const noexcept -> env { return {}; }
 };
 
+template <typename D>
+struct completion_domain_sender {
+    struct env {
+        auto query(test_std::get_completion_domain_t<test_std::set_value_t>) const noexcept -> D { return {}; }
+    };
+    using sender_concept        = test_std::sender_tag;
+    using completion_signatures = test_std::completion_signatures<test_std::set_value_t()>;
+    template <typename, typename...>
+    static consteval auto get_completion_signatures() -> completion_signatures {
+        return {};
+    }
+    auto get_env() const noexcept -> env { return {}; }
+};
+
 template <bool Expect, typename... S>
 auto test_when_all_available(S&&... s) {
     static_assert(Expect == requires { test_std::when_all(std::forward<S>(s)...); });
@@ -240,6 +254,12 @@ auto test_when_all() -> void {
         test_std::when_all(test_std::read_env(test_std::get_stop_token) | test_std::then([](auto&&) {})));
 }
 
+auto test_when_all_attrs() -> void {
+    auto s = test_std::when_all(completion_domain_sender<domain<0>>{}, completion_domain_sender<domain<0>>{});
+    static_assert(std::same_as<decltype(test_std::get_completion_domain<test_std::set_value_t>(test_std::get_env(s))),
+                               domain<0>>);
+}
+
 auto test_when_all_with_variant() -> void {
     auto s{test_std::when_all_with_variant(test_std::just(17), test_std::just('a', true))};
     auto res{test_std::sync_wait(s)};
@@ -270,6 +290,7 @@ TEST(exec_when_all) {
 
     try {
         test_when_all();
+        test_when_all_attrs();
         test_when_all_with_variant();
     } catch (...) {
         // NOLINTNEXTLINE(cert-dcl03-c,hicpp-static-assert,misc-static-assert)