diff --git a/libs/core/execution/include/hpx/execution/algorithms/ensure_started.hpp b/libs/core/execution/include/hpx/execution/algorithms/ensure_started.hpp
index b4a124a2e1cc..c749d20653ee 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/ensure_started.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/ensure_started.hpp
@@ -1,5 +1,6 @@
 //  Copyright (c) 2021 ETH Zurich
 //  Copyright (c) 2022 Hartmut Kaiser
+//  Copyright (c) 2026 The STE||AR-Group
 //
 //  SPDX-License-Identifier: BSL-1.0
 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -13,62 +14,438 @@
 #include <hpx/modules/execution_base.hpp>
 #else
 
+#include <hpx/assert.hpp>
 #include <hpx/execution/algorithms/detail/inject_scheduler.hpp>
 #include <hpx/execution/algorithms/detail/partial_algorithm.hpp>
 #include <hpx/execution/algorithms/run_loop.hpp>
-#include <hpx/execution/algorithms/split.hpp>
+#include <hpx/execution_base/completion_signatures.hpp>
+#include <hpx/execution_base/receiver.hpp>
+#include <hpx/execution_base/sender.hpp>
+#include <hpx/functional/invoke_fused.hpp>
+#include <hpx/functional/tag_invoke.hpp>
 #include <hpx/modules/allocator_support.hpp>
 #include <hpx/modules/concepts.hpp>
-#include <hpx/modules/execution_base.hpp>
-#include <hpx/modules/tag_invoke.hpp>
+#include <hpx/modules/datastructures.hpp>
+#include <hpx/modules/errors.hpp>
+#include <hpx/modules/memory.hpp>
+#include <hpx/modules/synchronization.hpp>
+#include <hpx/modules/thread_support.hpp>
+#include <hpx/modules/type_support.hpp>
 
+#include <atomic>
+#include <cstddef>
 #include <exception>
 #include <memory>
+#include <type_traits>
 #include <utility>
 
 namespace hpx::execution::experimental {
 
-    // execution::ensure_started is used to eagerly start the execution of a
-    // sender, while also providing a way to attach further work to execute once
-    // it has completed.
-    //
-    // Once ensure_started returns, it is known that the provided sender has
-    // been connected and start has been called on the resulting operation state
-    // (see 5.2 Operation states represent work); in other words, the work
-    // described by the provided sender has been submitted for execution on the
-    // appropriate execution contexts. Returns a sender which completes when the
-    // provided sender completes and sends values equivalent to those of the
-    // provided sender.
-    //
-    // If the returned sender is destroyed before execution::connect() is
-    // called, or if execution::connect() is called but the returned
-    // operation-state is destroyed before execution::start() is called, then a
-    // stop-request is sent to the eagerly launched operation and the operation
-    // is detached and will run to completion in the background. Its result will
-    // be discarded when it eventually completes.
-    //
-    // Note that the application will need to make sure that resources are kept
-    // alive in the case that the operation detaches. e.g. by holding a
-    // std::shared_ptr to those resources or otherwise having some out-of-band
-    // way to signal completion of the operation so that resource release can be
-    // sequenced after the completion.
-    //
+    namespace detail {
+
+        enum class ensure_started_state_enum
+        {
+            empty,
+            started,
+            completed
+        };
+
+        template <typename Receiver>
+        struct ensure_started_error_visitor
+        {
+            HPX_NO_UNIQUE_ADDRESS std::decay_t<Receiver>& receiver;
+
+            template <typename Error>
+            void operator()(Error const& error) noexcept
+            {
+                hpx::execution::experimental::set_error(
+                    HPX_MOVE(receiver), error);
+            }
+        };
+
+        template <typename Receiver>
+        struct ensure_started_value_visitor
+        {
+            HPX_NO_UNIQUE_ADDRESS std::decay_t<Receiver>& receiver;
+
+            template <typename Ts>
+            void operator()(Ts const& ts) noexcept
+            {
+                hpx::invoke_fused(
+                    hpx::bind_front(hpx::execution::experimental::set_value,
+                        HPX_MOVE(receiver)),
+                    ts);
+            }
+        };
+
+        template <typename Sender, typename Allocator>
+        struct ensure_started_sender
+        {
+            using is_sender = void;
+
+            template <typename Tuple>
+            struct value_types_helper
+            {
+                using const_type =
+                    hpx::util::detail::transform_t<Tuple, std::add_const>;
+                using type = hpx::util::detail::transform_t<const_type,
+                    std::add_lvalue_reference>;
+            };
+
+            template <typename Env>
+            struct generate_completion_signatures
+            {
+                template <template <typename...> typename Tuple,
+                    template <typename...> typename Variant>
+                using value_types = hpx::util::detail::transform_t<
+                    value_types_of_t<Sender, Env, Tuple, Variant>,
+                    value_types_helper>;
+
+                template <template <typename...> typename Variant>
+                using error_types =
+                    hpx::util::detail::unique_t<hpx::util::detail::prepend_t<
+                        error_types_of_t<Sender, Env, Variant>,
+                        std::exception_ptr>>;
+
+                static constexpr bool sends_stopped = true;
+            };
+
+            template <typename Env>
+            friend auto tag_invoke(
+                get_completion_signatures_t, ensure_started_sender const&, Env)
+                -> generate_completion_signatures<Env>;
+
+            friend auto tag_invoke(hpx::execution::experimental::get_env_t,
+                ensure_started_sender const& sender) noexcept
+            {
+                return hpx::execution::experimental::get_env(
+                    sender.state->sender_);
+            }
+
+            struct shared_state
+            {
+                struct ensure_started_receiver;
+
+                using allocator_type = typename std::allocator_traits<
+                    Allocator>::template rebind_alloc<shared_state>;
+                HPX_NO_UNIQUE_ADDRESS allocator_type alloc;
+
+                hpx::spinlock mtx;
+                hpx::util::atomic_count reference_count{0};
+                std::atomic<ensure_started_state_enum> state_enum{
+                    ensure_started_state_enum::empty};
+
+                using operation_state_type = std::decay_t<
+                    connect_result_t<Sender, ensure_started_receiver>>;
+                operation_state_type os;
+
+                using signatures = generate_completion_signatures<empty_env>;
+
+                struct stopped_type
+                {
+                };
+                using value_type = value_types_of_t<Sender, empty_env,
+                    decayed_tuple, hpx::variant>;
+                using error_type = detail::error_types_from<signatures,
+                    meta::func<hpx::variant>>;
+
+                hpx::variant<hpx::monostate, stopped_type, error_type,
+                    value_type>
+                    v;
+
+                using continuation_type = hpx::move_only_function<void()>;
+                hpx::detail::small_vector<continuation_type, 1> continuations;
+
+                // Store the predecessor sender to be able to extract its environment
+                HPX_NO_UNIQUE_ADDRESS std::decay_t<Sender> sender_;
+
+                struct ensure_started_receiver
+                {
+                    hpx::intrusive_ptr<shared_state> state;
+
+                    template <typename Error>
+                    friend void tag_invoke(set_error_t,
+                        ensure_started_receiver&& r, Error&& error) noexcept
+                    {
+                        HPX_MOVE(r).set_error(HPX_FORWARD(Error, error));
+                    }
+
+                    template <typename Error>
+                    void set_error(Error&& error) && noexcept
+                    {
+                        try
+                        {
+                            state->v.template emplace<error_type>(
+                                error_type(HPX_FORWARD(Error, error)));
+                        }
+                        catch (...)
+                        {
+                            std::terminate();
+                        }
+                        state->set_completed();
+                        state.reset();
+                    }
+
+                    friend void tag_invoke(
+                        set_stopped_t, ensure_started_receiver&& r) noexcept
+                    {
+                        if (r.state)
+                        {
+                            r.state->v.template emplace<stopped_type>();
+                            r.state->set_completed();
+                            r.state.reset();
+                        }
+                    };
+
+                    using value_type = value_types_of_t<Sender, empty_env,
+                        decayed_tuple, hpx::variant>;
+
+                    template <typename... Ts>
+                    friend auto tag_invoke(set_value_t,
+                        ensure_started_receiver&& r, Ts&&... ts) noexcept
+                        -> decltype(std::declval<hpx::variant<hpx::monostate,
+                                        value_type>>()
+                                        .template emplace<value_type>(
+                                            hpx::tuple<std::decay_t<Ts>...>(
+                                                HPX_FORWARD(Ts, ts)...)),
+                            void())
+                    {
+                        hpx::detail::try_catch_exception_ptr(
+                            [&]() {
+                                r.state->v.template emplace<value_type>(
+                                    hpx::make_tuple(HPX_FORWARD(Ts, ts)...));
+                                r.state->set_completed();
+                                r.state.reset();
+                            },
+                            [&](std::exception_ptr ep) {
+                                HPX_MOVE(r).set_error(HPX_MOVE(ep));
+                            });
+                    }
+                };
+
+                template <typename Sender_,
+                    HPX_CONCEPT_REQUIRES_(meta::value<
+                        meta::none_of<shared_state, std::decay_t<Sender_>>>)>
+                shared_state(Sender_&& sender, allocator_type const& alloc)
+                  : alloc(alloc)
+                  , os(hpx::execution::experimental::connect(
+                        HPX_FORWARD(Sender_, sender),
+                        ensure_started_receiver{this}))
+                  , sender_(HPX_FORWARD(Sender_, sender))
+                {
+                }
+
+                virtual ~shared_state()
+                {
+                    HPX_ASSERT_MSG(
+                        state_enum.load() != ensure_started_state_enum::empty,
+                        "start was never called on the operation state of "
+                        "ensure_started.");
+                }
+
+                template <typename Receiver>
+                struct done_error_value_visitor
+                {
+                    HPX_NO_UNIQUE_ADDRESS std::decay_t<Receiver> receiver;
+
+                    [[noreturn]] void operator()(hpx::monostate) const
+                    {
+                        HPX_UNREACHABLE;
+                    }
+
+                    void operator()(stopped_type)
+                    {
+                        hpx::execution::experimental::set_stopped(
+                            HPX_MOVE(receiver));
+                    }
+
+                    void operator()(error_type const& error)
+                    {
+                        hpx::visit(
+                            ensure_started_error_visitor<Receiver>{receiver},
+                            error);
+                    }
+
+                    void operator()(value_type const& ts)
+                    {
+                        hpx::visit(
+                            ensure_started_value_visitor<Receiver>{receiver},
+                            ts);
+                    }
+                };
+
+                void set_completed()
+                {
+                    state_enum.store(ensure_started_state_enum::completed);
+
+                    {
+                        std::unique_lock l{mtx};
+                    }
+
+                    if (!continuations.empty())
+                    {
+                        for (auto const& continuation : continuations)
+                        {
+                            continuation();
+                        }
+                        continuations.clear();
+                    }
+                }
+
+                template <typename Receiver>
+                void add_continuation(Receiver& receiver) = delete;
+
+                template <typename Receiver>
+                void add_continuation(Receiver&& receiver)
+                {
+                    if (state_enum.load() ==
+                        ensure_started_state_enum::completed)
+                    {
+                        hpx::visit(
+                            done_error_value_visitor<Receiver>{
+                                HPX_FORWARD(Receiver, receiver)},
+                            v);
+                    }
+                    else
+                    {
+                        std::unique_lock l{mtx};
+
+                        if (state_enum.load() ==
+                            ensure_started_state_enum::completed)
+                        {
+                            l.unlock();
+                            hpx::visit(
+                                done_error_value_visitor<Receiver>{
+                                    HPX_FORWARD(Receiver, receiver)},
+                                v);
+                        }
+                        else
+                        {
+                            continuations.emplace_back(
+                                [this,
+                                    receiver = HPX_FORWARD(
+                                        Receiver, receiver)]() mutable {
+                                    hpx::visit(
+                                        done_error_value_visitor<Receiver>{
+                                            HPX_MOVE(receiver)},
+                                        v);
+                                });
+                        }
+                    }
+                }
+
+                void start() & noexcept
+                {
+                    ensure_started_state_enum expected =
+                        ensure_started_state_enum::empty;
+                    if (state_enum.compare_exchange_strong(
+                            expected, ensure_started_state_enum::started))
+                    {
+                        hpx::execution::experimental::start(os);
+                    }
+                }
+
+                friend void intrusive_ptr_add_ref(shared_state* p) noexcept
+                {
+                    p->reference_count.increment();
+                }
+
+                friend void intrusive_ptr_release(shared_state* p) noexcept
+                {
+                    if (p->reference_count.decrement() == 0)
+                    {
+                        std::atomic_thread_fence(std::memory_order_acquire);
+
+                        allocator_type other_alloc(p->alloc);
+                        std::allocator_traits<allocator_type>::destroy(
+                            other_alloc, p);
+                        std::allocator_traits<allocator_type>::deallocate(
+                            other_alloc, p, 1);
+                    }
+                }
+            };
+
+            hpx::intrusive_ptr<shared_state> state;
+
+            template <typename Sender_>
+            ensure_started_sender(Sender_&& sender, Allocator const& allocator)
+            {
+                using allocator_type = Allocator;
+                using other_allocator = typename std::allocator_traits<
+                    allocator_type>::template rebind_alloc<shared_state>;
+                using allocator_traits = std::allocator_traits<other_allocator>;
+                using unique_ptr = std::unique_ptr<shared_state,
+                    util::allocator_deleter<other_allocator>>;
+
+                other_allocator alloc(allocator);
+                unique_ptr p(allocator_traits::allocate(alloc, 1),
+                    hpx::util::allocator_deleter<other_allocator>{alloc});
+
+                allocator_traits::construct(
+                    alloc, p.get(), HPX_FORWARD(Sender_, sender), allocator);
+                state = p.release();
+
+                state->start();
+            }
+
+            ensure_started_sender(ensure_started_sender const&) = default;
+            ensure_started_sender& operator=(
+                ensure_started_sender const&) = default;
+            ensure_started_sender(ensure_started_sender&&) = default;
+            ensure_started_sender& operator=(ensure_started_sender&&) = default;
+
+            template <typename Receiver>
+            struct operation_state
+            {
+                HPX_NO_UNIQUE_ADDRESS std::decay_t<Receiver> receiver;
+                hpx::intrusive_ptr<shared_state> state;
+
+                template <typename Receiver_>
+                operation_state(Receiver_&& receiver,
+                    hpx::intrusive_ptr<shared_state> state)
+                  : receiver(HPX_FORWARD(Receiver_, receiver))
+                  , state(HPX_MOVE(state))
+                {
+                }
+
+                operation_state(operation_state&&) = delete;
+                operation_state& operator=(operation_state&&) = delete;
+                operation_state(operation_state const&) = delete;
+                operation_state& operator=(operation_state const&) = delete;
+
+                friend void tag_invoke(start_t, operation_state& os) noexcept
+                {
+                    os.state->add_continuation(HPX_MOVE(os.receiver));
+                }
+            };
+
+            template <typename Receiver>
+            friend operation_state<Receiver> tag_invoke(
+                connect_t, ensure_started_sender&& s, Receiver&& receiver)
+            {
+                return {HPX_FORWARD(Receiver, receiver), HPX_MOVE(s.state)};
+            }
+
+            template <typename Receiver>
+            friend operation_state<Receiver> tag_invoke(
+                connect_t, ensure_started_sender const& s, Receiver&& receiver)
+            {
+                return {HPX_FORWARD(Receiver, receiver), s.state};
+            }
+        };
+    }    // namespace detail
+
     HPX_CXX_CORE_EXPORT inline constexpr struct ensure_started_t final
       : hpx::functional::detail::tag_priority<ensure_started_t>
     {
     private:
-        // clang-format off
         template <typename Sender,
             typename Allocator = hpx::util::internal_allocator<>,
-            HPX_CONCEPT_REQUIRES_(
-                is_sender_v<Sender> &&
-                hpx::traits::is_allocator_v<Allocator> &&
-                experimental::detail::is_completion_scheduler_tag_invocable_v<
-                    hpx::execution::experimental::set_value_t,
-                    Sender, ensure_started_t, Allocator
-                >
-            )>
-        // clang-format on
+            HPX_CONCEPT_REQUIRES_(is_sender_v<Sender>&&
+                    hpx::traits::is_allocator_v<Allocator>&& experimental::
+                        detail::is_completion_scheduler_tag_invocable_v<
+                            hpx::execution::experimental::set_value_t, Sender,
+                            ensure_started_t, Allocator>)>
         friend constexpr HPX_FORCEINLINE auto tag_override_invoke(
             ensure_started_t, Sender&& sender, Allocator const& allocator = {})
         {
@@ -80,61 +457,53 @@ namespace hpx::execution::experimental {
                 HPX_MOVE(scheduler), HPX_FORWARD(Sender, sender), allocator);
         }
 
-        // clang-format off
         template <typename Sender,
             typename Allocator = hpx::util::internal_allocator<>,
             HPX_CONCEPT_REQUIRES_(
-                hpx::execution::experimental::is_sender_v<Sender> &&
-                hpx::traits::is_allocator_v<Allocator>
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_invoke(ensure_started_t,
-            hpx::execution::experimental::run_loop_scheduler const& sched,
-            Sender&& sender, Allocator const& allocator = {})
+                is_sender_v<Sender>&& hpx::traits::is_allocator_v<Allocator>)>
+        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
+            ensure_started_t, Sender&& sender, Allocator const& allocator = {})
         {
-            auto split_sender = detail::split_sender<Sender, Allocator,
-                detail::submission_type::eager,
-                hpx::execution::experimental::run_loop_scheduler>{
-                HPX_FORWARD(Sender, sender), allocator, sched};
-
-            sched.get_run_loop().run();
-            return split_sender;
+            return detail::ensure_started_sender<Sender, Allocator>{
+                HPX_FORWARD(Sender, sender), allocator};
         }
 
-        // clang-format off
         template <typename Sender,
             typename Allocator = hpx::util::internal_allocator<>,
-            HPX_CONCEPT_REQUIRES_(
-                is_sender_v<Sender> &&
-                hpx::traits::is_allocator_v<Allocator>
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            ensure_started_t, Sender&& sender, Allocator const& allocator = {})
+            HPX_CONCEPT_REQUIRES_(hpx::execution::experimental::is_sender_v<
+                Sender>&& hpx::traits::is_allocator_v<Allocator>)>
+        friend constexpr HPX_FORCEINLINE auto tag_invoke(ensure_started_t,
+            hpx::execution::experimental::run_loop_scheduler const& sched,
+            Sender&& sender, Allocator const& allocator = {})
         {
-            return detail::split_sender<Sender, Allocator,
-                detail::submission_type::eager>{
+            auto es_sender = detail::ensure_started_sender<Sender, Allocator>{
                 HPX_FORWARD(Sender, sender), allocator};
+
+            sched.get_run_loop().run();
+            return es_sender;
         }
 
         template <typename Sender, typename Allocator>
         friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
             ensure_started_t,
-            detail::split_sender<Sender, Allocator,
-                detail::submission_type::eager>
-                sender,
+            detail::ensure_started_sender<Sender, Allocator> sender,
             Allocator const& = {})
         {
             return sender;
         }
 
-        // clang-format off
+        template <typename Allocator = hpx::util::internal_allocator<>,
+            HPX_CONCEPT_REQUIRES_(hpx::traits::is_allocator_v<Allocator>)>
+        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
+            ensure_started_t, Allocator const& allocator = {})
+        {
+            return detail::partial_algorithm<ensure_started_t, Allocator>{
+                allocator};
+        }
+
         template <typename Scheduler, typename Allocator,
-            HPX_CONCEPT_REQUIRES_(
-                hpx::execution::experimental::is_scheduler_v<Scheduler> &&
-                hpx::traits::is_allocator_v<Allocator>
-            )>
-        // clang-format on
+            HPX_CONCEPT_REQUIRES_(hpx::execution::experimental::is_scheduler_v<
+                Scheduler>&& hpx::traits::is_allocator_v<Allocator>)>
         friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
             ensure_started_t, Scheduler&& scheduler,
             Allocator const& allocator = {})
@@ -143,19 +512,6 @@ namespace hpx::execution::experimental {
                 ensure_started_t, Scheduler, Allocator>{
                 HPX_FORWARD(Scheduler, scheduler), allocator};
         }
-
-        // clang-format off
-        template <typename Allocator = hpx::util::internal_allocator<>,
-            HPX_CONCEPT_REQUIRES_(
-                hpx::traits::is_allocator_v<Allocator>
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            ensure_started_t, Allocator const& allocator = {})
-        {
-            return detail::partial_algorithm<ensure_started_t, Allocator>{
-                allocator};
-        }
     } ensure_started{};
 }    // namespace hpx::execution::experimental
 
diff --git a/libs/core/execution/tests/unit/algorithm_ensure_started.cpp b/libs/core/execution/tests/unit/algorithm_ensure_started.cpp
index a0e665bb2a6d..ad6368b589a7 100644
--- a/libs/core/execution/tests/unit/algorithm_ensure_started.cpp
+++ b/libs/core/execution/tests/unit/algorithm_ensure_started.cpp
@@ -1,374 +1,110 @@
 //  Copyright (c) 2021 ETH Zurich
 //  Copyright (c) 2022 Hartmut Kaiser
+//  Copyright (c) 2026 The STE||AR-Group
 //
 //  SPDX-License-Identifier: BSL-1.0
 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
 //  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+#include <hpx/config.hpp>
+#include <hpx/init.hpp>
 #include <hpx/modules/execution.hpp>
 #include <hpx/modules/testing.hpp>
 
-#include "algorithm_test_utils.hpp"
-
 #include <atomic>
 #include <exception>
 #include <stdexcept>
 #include <string>
 #include <type_traits>
 #include <utility>
+#include <vector>
 
 namespace ex = hpx::execution::experimental;
 
-// This overload is only used to check dispatching. It is not a useful
-// implementation.
-template <typename Allocator = hpx::util::internal_allocator<>>
-auto tag_invoke(ex::ensure_started_t, custom_sender_tag_invoke s,
-    Allocator const& = Allocator{})
-{
-    s.tag_invoke_overload_called = true;
-    return void_sender{};
-}
-
-int main()
+void test_eager_execution()
 {
-    // Success path
-    {
-        std::atomic<bool> set_value_called{false};
-        std::atomic<bool> started{false};
-        auto s1 = ex::then(void_sender{}, [&]() { started = true; });
-        auto s2 = ex::ensure_started(std::move(s1));
-        static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
-        static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
-
-        check_value_types<hpx::variant<hpx::tuple<>>>(s2);
-        check_error_types<hpx::variant<std::exception_ptr>>(s2);
-        check_sends_stopped<true>(s2);
-
-        HPX_TEST(started);
-        auto f = [] {};
-        auto r = callback_receiver<decltype(f)>{f, set_value_called};
-        auto os = ex::connect(std::move(s2), std::move(r));
-        ex::start(os);
-        HPX_TEST(set_value_called);
-    }
-
-    {
-        std::atomic<bool> set_value_called{false};
-        std::atomic<bool> started{false};
-        auto s1 = ex::then(ex::just(0), [&](int x) {
-            started = true;
-            return x;
-        });
-        auto s2 = ex::ensure_started(std::move(s1));
-        static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
-        static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
-
-#if defined(HPX_HAVE_STDEXEC)
-        // Passes by value
-        check_value_types<hpx::variant<hpx::tuple<int>>>(s2);
-#else
-        check_value_types<hpx::variant<hpx::tuple<int const&>>>(s2);
-#endif
-        check_error_types<hpx::variant<std::exception_ptr>>(s2);
-        check_sends_stopped<true>(s2);
-
-        HPX_TEST(started);
-        auto f = [](int x) { HPX_TEST_EQ(x, 0); };
-        auto r = callback_receiver<decltype(f)>{f, set_value_called};
-        auto os = ex::connect(std::move(s2), std::move(r));
-        ex::start(os);
-        HPX_TEST(set_value_called);
-    }
-
-    {
-        std::atomic<bool> set_value_called{false};
-        std::atomic<bool> started{false};
-        auto s1 = ex::then(ex::just(custom_type_non_default_constructible{42}),
-            [&](custom_type_non_default_constructible x) {
-                started = true;
-                return x;
-            });
-        auto s2 = ex::ensure_started(std::move(s1));
-        static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
-        static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
+    std::atomic<bool> started{false};
 
-#if defined(HPX_HAVE_STDEXEC)
-        check_value_types<
-            hpx::variant<hpx::tuple<custom_type_non_default_constructible>>>(
-            s2);
-#else
-        check_value_types<hpx::variant<
-            hpx::tuple<custom_type_non_default_constructible const&>>>(s2);
-#endif
-        check_error_types<hpx::variant<std::exception_ptr>>(s2);
-        check_sends_stopped<true>(s2);
+    // Sender that sets started to true when executed
+    auto s1 = ex::then(ex::just(), [&]() { started = true; });
 
-        HPX_TEST(started);
-        auto f = [](auto x) { HPX_TEST_EQ(x.x, 42); };
-        auto r = callback_receiver<decltype(f)>{f, set_value_called};
-        auto os = ex::connect(std::move(s2), std::move(r));
-        ex::start(os);
-        HPX_TEST(set_value_called);
-    }
+    // Eagerly start the sender
+    auto s2 = ex::ensure_started(std::move(s1));
 
-    {
-        std::atomic<bool> set_value_called{false};
-        std::atomic<bool> started{false};
-        auto s1 = ex::then(
-            ex::just(custom_type_non_default_constructible_non_copyable{42}),
-            [&](custom_type_non_default_constructible_non_copyable&& x) {
-                started = true;
-                return std::move(x);
-            });
-        auto s2 = ex::ensure_started(std::move(s1));
-        static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
-        static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
+    // Test Case 1: Ensure work starts even if the resulting sender isn't connected
+    // ensure_started immediately connects and starts the predecessor
+    HPX_TEST(started.load());
 
-#if defined(HPX_HAVE_STDEXEC)
-        // custom_type_non_default_constructible_non_copyable Will be move constructed
-        check_value_types<hpx::variant<
-            hpx::tuple<custom_type_non_default_constructible_non_copyable>>>(
-            s2);
-        check_error_types<hpx::variant<std::exception_ptr>>(s2);
-#else
-        check_value_types<hpx::variant<hpx::tuple<
-            custom_type_non_default_constructible_non_copyable const&>>>(s2);
-        check_error_types<hpx::variant<std::exception_ptr>>(s2);
-#endif
-        check_sends_stopped<true>(s2);
+    // Connect it to sink the result, avoiding memory leaks from the shared state
+    std::atomic<bool> set_value_called{false};
+    auto s3 = ex::then(std::move(s2), [&]() { set_value_called = true; });
+    hpx::this_thread::experimental::sync_wait(std::move(s3));
 
-        HPX_TEST(started);
-        auto f = [](auto& x) { HPX_TEST_EQ(x.x, 42); };
-        auto r = callback_receiver<decltype(f)>{f, set_value_called};
-#if defined(HPX_HAVE_STDEXEC)
-        auto os = ex::connect(std::move(s2) | ex::split(), std::move(r));
-#else
-        auto os = ex::connect(std::move(s2), std::move(r));
-#endif
-        ex::start(os);
-        HPX_TEST(set_value_called);
-    }
+    HPX_TEST(set_value_called.load());
+}
 
-    // operator| overload
-    {
-        std::atomic<bool> set_value_called{false};
-        auto s = void_sender{} | ex::ensure_started();
-        static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
-        static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
+void test_multiple_connects()
+{
+    std::atomic<int> start_count{0};
 
-        check_value_types<hpx::variant<hpx::tuple<>>>(s);
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-        check_sends_stopped<true>(s);
+    auto s1 = ex::then(ex::just(), [&]() {
+        ++start_count;
+        return 42;
+    });
 
-        auto f = [] {};
-        auto r = callback_receiver<decltype(f)>{f, set_value_called};
-        auto os = ex::connect(std::move(s), std::move(r));
-        ex::start(os);
-        HPX_TEST(set_value_called);
-    }
+    auto s2 = ex::ensure_started(std::move(s1));
 
-    // tag_invoke overload
-    {
-        std::atomic<bool> receiver_set_value_called{false};
-        std::atomic<bool> tag_invoke_overload_called{false};
-        auto s = custom_sender_tag_invoke{tag_invoke_overload_called} |
-            ex::ensure_started();
-        static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
-        static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
+    HPX_TEST_EQ(start_count.load(), 1);
 
-        // custom_sender_tag_invoke implements tag_invoke(split_t, ...)
-        // returning an instance of void_sender
-        check_value_types<hpx::variant<hpx::tuple<>>>(s);
-        check_error_types<hpx::variant<>>(s);
-        check_sends_stopped<false>(s);
+    // Test Case 2: Ensure multiple connects to the same started operation receive the same value
+    int result1 = 0;
+    auto s3 = ex::then(s2, [&](int val) { result1 = val; });
+    hpx::this_thread::experimental::sync_wait(std::move(s3));
+    HPX_TEST_EQ(result1, 42);
 
-        auto f = [] {};
-        auto r = callback_receiver<decltype(f)>{f, receiver_set_value_called};
-        auto os = ex::connect(std::move(s), std::move(r));
-        ex::start(os);
-        HPX_TEST(receiver_set_value_called);
-        HPX_TEST(tag_invoke_overload_called);
-    }
+    int result2 = 0;
+    auto s4 = ex::then(s2, [&](int val) { result2 = val; });
+    hpx::this_thread::experimental::sync_wait(std::move(s4));
+    HPX_TEST_EQ(result2, 42);
 
-    // Failure path
-    {
-        std::atomic<bool> set_error_called{false};
-        auto s = error_sender{} | ex::ensure_started();
-        static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
-        static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
-
-        check_value_types<hpx::variant<hpx::tuple<>>>(s);
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-        check_sends_stopped<true>(s);
+    // The predecessor should only have been started ONCE!
+    HPX_TEST_EQ(start_count.load(), 1);
+}
 
-        auto r = error_callback_receiver<check_exception_ptr>{
-            check_exception_ptr{}, set_error_called};
-        auto os = ex::connect(std::move(s), std::move(r));
-        ex::start(os);
-        HPX_TEST(set_error_called);
-    }
+void test_error_propagation()
+{
+    auto s1 = ex::then(ex::just(), []() { throw std::runtime_error("error"); });
+    auto s2 = ex::ensure_started(std::move(s1));
 
+    bool caught = false;
+    try
     {
-        std::atomic<bool> set_error_called{false};
-        auto s = error_sender{} | ex::ensure_started() | ex::ensure_started() |
-            ex::ensure_started();
-        static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
-        static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
-
-        check_value_types<hpx::variant<hpx::tuple<>>>(s);
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-        check_sends_stopped<true>(s);
-
-        auto r = error_callback_receiver<check_exception_ptr>{
-            check_exception_ptr{}, set_error_called};
-        auto os = ex::connect(std::move(s), std::move(r));
-        ex::start(os);
-        HPX_TEST(set_error_called);
+        hpx::this_thread::experimental::sync_wait(s2);
     }
-
-    // Chained ensure_started calls do not create new shared states
+    catch (std::runtime_error const&)
     {
-        std::atomic<bool> receiver_set_value_called{false};
-        auto s1 = ex::just() | ex::ensure_started();
-        static_assert(ex::is_sender_v<decltype(s1)>);
-#if defined(HPX_HAVE_STDEXEC)
-        static_assert(ex::is_sender_in_v<decltype(s1), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s1), ex::empty_env>);
-#endif
-
-        check_value_types<hpx::variant<hpx::tuple<>>>(s1);
-        check_error_types<hpx::variant<std::exception_ptr>>(s1);
-        check_sends_stopped<true>(s1);
-
-#if defined(HPX_HAVE_STDEXEC)
-        auto s2 = ex::ensure_started(std::move(s1));
-#else
-        auto s2 = ex::ensure_started(s1);
-        HPX_TEST_EQ(s1.state, s2.state);
-#endif
-        static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
-        static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
-
-        check_value_types<hpx::variant<hpx::tuple<>>>(s2);
-        check_error_types<hpx::variant<std::exception_ptr>>(s2);
-        check_sends_stopped<true>(s2);
-
-        auto s3 = ex::ensure_started(std::move(s2));
-        static_assert(ex::is_sender_v<decltype(s3)>);
-#if defined(HPX_HAVE_STDEXEC)
-        static_assert(ex::is_sender_in_v<decltype(s3), ex::empty_env>);
-#else
-        HPX_TEST_EQ(s1.state, s3.state);
-        static_assert(ex::is_sender_v<decltype(s3), ex::empty_env>);
-#endif
-
-        check_value_types<hpx::variant<hpx::tuple<>>>(s3);
-        check_error_types<hpx::variant<std::exception_ptr>>(s3);
-        check_sends_stopped<true>(s3);
-
-        auto f = [] {};
-        auto r = callback_receiver<decltype(f)>{f, receiver_set_value_called};
-        auto os = ex::connect(std::move(s3), std::move(r));
-        ex::start(os);
-        HPX_TEST(receiver_set_value_called);
+        caught = true;
     }
 
-    {
-        std::atomic<bool> receiver_set_value_called{false};
-        auto s1 = ex::just(42) | ex::ensure_started();
-        static_assert(ex::is_sender_v<decltype(s1)>);
-#if defined(HPX_HAVE_STDEXEC)
-        static_assert(ex::is_sender_in_v<decltype(s1), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s1), ex::empty_env>);
-#endif
-
-#if defined(HPX_HAVE_STDEXEC)
-        check_value_types<hpx::variant<hpx::tuple<int>>>(s1);
-#else
-        check_value_types<hpx::variant<hpx::tuple<int const&>>>(s1);
-#endif
-        check_error_types<hpx::variant<std::exception_ptr>>(s1);
-        check_sends_stopped<true>(s1);
-
-#if defined(HPX_HAVE_STDEXEC)
-        auto s2 = ex::ensure_started(std::move(s1));
-#else
-        auto s2 = ex::ensure_started(s1);
-        HPX_TEST_EQ(s1.state, s2.state);
-#endif
-        static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
-        static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
-
-#if defined(HPX_HAVE_STDEXEC)
-        check_value_types<hpx::variant<hpx::tuple<int>>>(s2);
-#else
-        check_value_types<hpx::variant<hpx::tuple<int const&>>>(s2);
-#endif
-        check_error_types<hpx::variant<std::exception_ptr>>(s2);
-        check_sends_stopped<true>(s2);
+    HPX_TEST(caught);
+}
 
-        auto s3 = ex::ensure_started(std::move(s2));
-        static_assert(ex::is_sender_v<decltype(s3)>);
-#if defined(HPX_HAVE_STDEXEC)
-        static_assert(ex::is_sender_in_v<decltype(s3), ex::empty_env>);
-        check_value_types<hpx::variant<hpx::tuple<int>>>(s3);
-#else
-        static_assert(ex::is_sender_v<decltype(s3), ex::empty_env>);
-        HPX_TEST_EQ(s1.state, s3.state);
-        check_value_types<hpx::variant<hpx::tuple<int const&>>>(s3);
-#endif
+int hpx_main()
+{
+    test_eager_execution();
+    test_multiple_connects();
+    test_error_propagation();
+    return hpx::local::finalize();
+}
 
-        check_error_types<hpx::variant<std::exception_ptr>>(s3);
-        check_sends_stopped<true>(s3);
+int main(int argc, char* argv[])
+{
+    std::vector<std::string> const cfg = {"hpx.os_threads=all"};
+    hpx::local::init_params init_args;
+    init_args.cfg = cfg;
 
-        auto f = [](int x) { HPX_TEST_EQ(x, 42); };
-        auto r = callback_receiver<decltype(f)>{f, receiver_set_value_called};
-        auto os = ex::connect(std::move(s3), std::move(r));
-        ex::start(os);
-        HPX_TEST(receiver_set_value_called);
-    }
+    HPX_TEST_EQ_MSG(hpx::local::init(hpx_main, argc, argv, init_args), 0,
+        "HPX main exited with non-zero status");
 
     return hpx::util::report_errors();
 }