diff --git a/stl/inc/execution b/stl/inc/execution
index 9df2458b2e2..c22f21a7d2c 100644
--- a/stl/inc/execution
+++ b/stl/inc/execution
@@ -5021,6 +5021,647 @@ _FwdIt2 adjacent_difference(_ExPo&&, const _FwdIt1 _First, const _FwdIt1 _Last,
                              _Get_unwrapped_n(_Dest, _Idl_distance<_FwdIt1>(_UFirst, _ULast)), _Pass_fn(_Diff_op)));
     return _Dest;
 }
+
+#ifdef __cpp_lib_executors
+namespace execution {
+    template <class _Ty>
+    concept _Movable_value = move_constructible<remove_cvref_t<_Ty>> && constructible_from<remove_cvref_t<_Ty>, _Ty>;
+
+    template <class _Sender>
+    concept _Scheduler_base = copy_constructible<remove_cvref_t<_Sender>> //
+        && equality_comparable<remove_cvref_t<_Sender>> //
+        && is_nothrow_copy_constructible_v<remove_cvref_t<_Sender>> //
+        && is_nothrow_destructible_v<remove_cvref_t<_Sender>> //
+        && noexcept(_STD declval<remove_cvref_t<_Sender>>() == _STD declval<remove_cvref_t<_Sender>>());
+
+    namespace _Schedule {
+        struct _Cpo {
+            template <_Scheduler_base _Scheduler>
+                requires tag_invocable<_Cpo, _Scheduler>
+            constexpr auto operator()(_Scheduler _Sched) const noexcept(nothrow_tag_invocable<_Cpo, _Scheduler>) {
+                return tag_invoke(*this, _STD forward<_Scheduler>(_Sched));
+            }
+        };
+    } // namespace _Schedule
+    using schedule_t = _Schedule::_Cpo;
+
+    inline namespace _Cpos {
+        inline constexpr _Schedule::_Cpo schedule;
+    } // namespace _Cpos
+
+    template <class _Sender>
+    concept scheduler = _Scheduler_base<_Sender> && requires(_Sender&& __s) {
+        {_EXEC schedule(_STD forward<_Sender>(__s))};
+    };
+
+    enum class forward_progress_guarantee { concurrent, parallel, weakly_parallel };
+
+    namespace _Get_forward_progress_guarantee {
+        struct _Cpo {
+            template <scheduler _Scheduler>
+            _NODISCARD constexpr auto operator()(_Scheduler&& _Sched) const noexcept {
+                if constexpr (tag_observable<_Cpo, _Scheduler>) {
+                    return tag_invoke(*this, _STD as_const(_Sched));
+                } else {
+                    return forward_progress_guarantee::weakly_parallel;
+                }
+            }
+        };
+    } // namespace _Get_forward_progress_guarantee
+    using get_forward_progress_guarantee_t = _Get_forward_progress_guarantee::_Cpo;
+
+    inline namespace _Cpos {
+        inline constexpr _Get_forward_progress_guarantee::_Cpo get_forward_progress_guarantee;
+    } // namespace _Cpos
+} // namespace execution
+
+namespace this_thread {
+    namespace _Execute_may_block_caller {
+        struct _Cpo {
+            template <_EXEC scheduler _Scheduler>
+            _NODISCARD constexpr bool operator()(_Scheduler&& _Sched) const noexcept {
+                if constexpr (tag_observable<_Cpo, _Scheduler> //
+                              && same_as<tag_invoke_result_t<_Cpo, _Scheduler>, bool>) {
+                    return tag_invoke(*this, _STD as_const(_Sched));
+                } else {
+                    return true;
+                }
+            }
+        };
+    } // namespace _Execute_may_block_caller
+    using execute_may_block_caller_t = _Execute_may_block_caller::_Cpo;
+
+    inline namespace _Cpos {
+        inline constexpr _Execute_may_block_caller::_Cpo execute_may_block_caller;
+    } // namespace _Cpos
+} // namespace this_thread
+
+namespace execution {
+    namespace _Set_value {
+        struct _Cpo {
+            // clang-format off
+            template <_Movable_value _Receiver, class... _Types>
+                requires tag_invocable<_Cpo, _Receiver, _Types...>
+            _NODISCARD constexpr auto operator()(_Receiver&& _Rec, _Types&&... _Args) const noexcept(
+                nothrow_tag_invocable<_Cpo, _Receiver, _Types...>) {
+                // clang-format on
+                return tag_invoke(*this, _STD forward<_Receiver>(_Rec), _STD forward<_Types>(_Args)...);
+            }
+        };
+    } // namespace _Set_value
+    using set_value_t = _Set_value::_Cpo;
+
+    inline namespace _Cpos {
+        inline constexpr _Set_value::_Cpo set_value;
+    }
+
+    namespace _Set_error {
+        struct _Cpo {
+            // clang-format off
+            template <_Movable_value _Receiver, class _Exception>
+                requires tag_invocable<_Cpo, _Receiver, _Exception>
+            _NODISCARD constexpr auto operator()(_Receiver&& _Rec, _Exception&& _Except) const
+                noexcept(nothrow_tag_invocable<_Cpo, _Receiver, _Exception>) {
+                // clang-format on
+                return tag_invoke(*this, _STD forward<_Receiver>(_Rec), _STD forward<_Exception>(_Except));
+            }
+        };
+    } // namespace _Set_error
+    using set_error_t = _Set_error::_Cpo;
+
+    inline namespace _Cpos {
+        inline constexpr _Set_error::_Cpo set_error;
+    }
+
+    namespace _Set_done {
+        struct _Cpo {
+            // clang-format off
+            template <_Movable_value _Receiver>
+                requires tag_invocable<_Cpo, _Receiver>
+            _NODISCARD constexpr auto operator()(_Receiver&& _Rec) const
+                noexcept(nothrow_tag_invocable<_Cpo, _Receiver>) {
+                // clang-format on
+                return tag_invoke(*this, _STD forward<_Receiver>(_Rec));
+            }
+        };
+    } // namespace _Set_done
+    using set_done_t = _Set_done::_Cpo;
+
+    inline namespace _Cpos {
+        inline constexpr _Set_done::_Cpo set_done;
+    }
+
+    // clang-format off
+    template <class _Ty, class _Exception = exception_ptr>
+    concept receiver = _Movable_value<_Ty> && requires (remove_cvref_t<_Ty>&& __t, _Exception&& __e) {
+        { _EXEC set_done(_STD move(__t)) } noexcept;
+        { _EXEC set_error(_STD move(__t), _STD forward<_Exception>(__e)) } noexcept;
+    };
+
+    template <class _Ty, class... _Types>
+    concept receiver_of = receiver<_Ty> && requires (remove_cvref_t<_Ty>&& __t, _Types&&... __args) {
+        { _EXEC set_value(_STD move(__t), _STD forward<_Types>(__args)...) };
+    };
+    // clang-format on
+
+    namespace _Get_scheduler {
+        struct _Cpo {
+            // clang-format off
+            template <receiver _Receiver>
+                requires tag_observable<_Cpo, _Receiver>
+            _NODISCARD constexpr auto operator()(_Receiver&& _Rec) const noexcept {
+                // clang-format on
+                return tag_invoke(*this, _STD as_const(_Rec));
+            }
+        };
+    } // namespace _Get_scheduler
+    using get_scheduler_t = _Get_scheduler::_Cpo;
+
+    inline namespace _Cpos {
+        inline constexpr _Get_scheduler::_Cpo get_scheduler;
+    }
+
+    namespace _Get_allocator {
+        struct _Cpo {
+            // clang-format off
+            template <receiver _Receiver>
+                requires tag_observable<_Cpo, _Receiver>
+            _NODISCARD constexpr auto operator()(_Receiver&& _Rec) const noexcept {
+                // clang-format on
+                return tag_invoke(*this, _STD as_const(_Rec));
+            }
+        };
+    } // namespace _Get_allocator
+    using get_allocator_t = _Get_allocator::_Cpo;
+
+    inline namespace _Cpos {
+        inline constexpr _Get_allocator::_Cpo get_allocator;
+    }
+
+    namespace _Get_stop_token {
+        struct _Cpo {
+            template <receiver _Receiver>
+            _NODISCARD constexpr auto operator()(_Receiver&& _Rec) const noexcept {
+                if constexpr (tag_observable<_Cpo, _Receiver>) {
+                    return tag_invoke(*this, _STD as_const(_Rec));
+                } else {
+                    return never_stop_token{};
+                }
+            }
+        };
+    } // namespace _Get_stop_token
+    using get_stop_token_t = _Get_stop_token::_Cpo;
+
+    inline namespace _Cpos {
+        inline constexpr _Get_stop_token::_Cpo get_stop_token;
+    }
+
+    namespace _Operation_state_start {
+        struct _Cpo {
+            // clang-format off
+            template <class _Ty>
+                requires destructible<_Ty> && is_object_v<_Ty> && nothrow_tag_invocable<_Cpo, _Ty&>
+            _NODISCARD constexpr auto operator()(_Ty& _State) const noexcept {
+                // clang-format on
+                return tag_invoke(*this, _State);
+            }
+        };
+    } // namespace _Operation_state_start
+    using start_t = _Operation_state_start::_Cpo;
+
+    inline namespace _Cpos {
+        inline constexpr _Operation_state_start::_Cpo start;
+    }
+
+    template <class _Ty>
+    concept operation_state = destructible<_Ty> && is_object_v<_Ty> && requires(_Ty& __t) {
+        // clang-format off
+        {_EXEC start(__t)} noexcept;
+        // clang-format on
+    };
+
+    template <template <template <class...> class, template <class...> class> class>
+    struct _Traits_has_values;
+
+    template <template <template <class...> class> class>
+    struct _Traits_has_errors;
+
+    template <class _Sender>
+    concept _Has_sender_types = requires {
+        typename _Traits_has_values<_Sender::template value_types>;
+        typename _Traits_has_errors<_Sender::template error_types>;
+        typename bool_constant<_Sender::sends_done>;
+    };
+
+    struct sender_base {};
+    struct _Sender_traits_base {};
+
+    struct _No_sender_traits {
+        using _Unspecialized = void;
+    };
+
+#if 0 // TRANSITION: coroutine support
+    template <bool _SendsDone>
+    struct _Void_sender {
+        template <template <class...> class _Tuple, template <class...> class _Variant>
+        using value_types = _Variant<_Tuple<>>;
+        template <template <class...> class _Variant>
+        using error_types                = _Variant<exception_ptr>;
+        static constexpr bool sends_done = _SendsDone;
+    };
+
+    template <bool _SendsDone, class... _Types>
+    struct _Sender_of {
+        template <template <class...> class _Tuple, template <class...> class _Variant>
+        using value_types = _Variant<_Tuple<_Types...>>;
+        template <template <class...> class _Variant>
+        using error_types                = _Variant<exception_ptr>;
+        static constexpr bool sends_done = _SendsDone;
+    };
+#endif // 0 TRANSITION: coroutine support
+
+    template <class _Sender>
+    struct _Typed_sender {
+        template <template <class...> class _Tuple, template <class...> class _Variant>
+        using value_types = typename _Sender::template value_types<_Tuple, _Variant>;
+        template <template <class...> class _Variant>
+        using error_types                = typename _Sender::template error_types<_Variant>;
+        static constexpr bool sends_done = _Sender::sends_done;
+    };
+
+    template <class _Sender>
+    _NODISCARD _CONSTEVAL auto _Get_sender_traits_base() noexcept {
+        if constexpr (_Has_sender_types<_Sender>) {
+            return _Typed_sender<_Sender>{};
+        } else if constexpr (derived_from<_Sender, sender_base>) {
+            return _Sender_traits_base{};
+#if 0 // TRANSITION: coroutine support
+            } else if constexpr (_Is_awaitable<_Sender>) {
+                if constexpr (is_void_v<_Await_result_t<_Sender>>) {
+                    return _Void_sender<false>{};
+                } else {
+                    return _Sender_of<false, _Await_result_t<_Sender>>{};
+                }
+#endif // 0 TRANSITION: coroutine support
+        } else {
+            return _No_sender_traits{};
+        }
+    }
+
+    template <class _Sender>
+    struct sender_traits : decltype(_Get_sender_traits_base<_Sender>()) {};
+
+    template <class _Sender>
+    _NODISCARD _CONSTEVAL auto _Get_sender_traits_derived() noexcept {
+        if constexpr (_Has_sender_types<sender_traits<_Sender>>) {
+            return _Typed_sender<sender_traits<_Sender>>{};
+        } else if constexpr (derived_from<_Sender, sender_base>) {
+            return _Sender_traits_base{};
+#if 0 // TRANSITION: coroutine support
+            } else if constexpr (_Is_awaitable<_Sender>) {
+                if constexpr (is_void_v<_Await_result_t<_Sender>>) {
+                    return _Void_sender<false>{};
+                } else {
+                    return _Sender_of<false, _Await_result_t<_Sender>>{};
+                }
+#endif // 0 TRANSITION: coroutine support
+        } else {
+            return _No_sender_traits{};
+        }
+    }
+
+    template <class _Sender>
+    concept sender = move_constructible<remove_cvref_t<_Sender>> && !requires {
+        typename sender_traits<remove_cvref_t<_Sender>>::_Unspecialized;
+    };
+
+    namespace _Connect {
+        struct _Cpo {
+            // clang-format off
+            template <sender _Sender, receiver _Receiver>
+                requires tag_invocable<_Cpo, _Sender, _Receiver>
+                      && operation_state<tag_invoke_result_t<_Cpo, _Sender, _Receiver>>
+            _NODISCARD constexpr auto operator()(_Sender&& _Send, _Receiver&& _Rec) const
+                noexcept(nothrow_tag_invocable<_Cpo, _Sender, _Receiver>) {
+                // clang-format on
+                return tag_invoke(*this, _STD forward<_Sender>(_Send), _STD forward<_Receiver>(_Rec));
+            }
+
+            // TRANSITION: Support for coroutines
+        };
+    } // namespace _Connect
+    using connect_t = _Connect::_Cpo;
+
+    inline namespace _Cpos {
+        inline constexpr _Connect::_Cpo connect;
+    }
+
+    template <class _Sender, class _Receiver>
+    concept sender_to = sender<_Sender> && receiver<_Receiver> && requires(_Sender&& __s, _Receiver&& __r) {
+        _EXEC connect(_STD forward<_Sender>(__s), _STD forward<_Receiver>(__r));
+    };
+
+    template <class _Sender>
+    concept typed_sender = sender<_Sender> && _Has_sender_types<sender_traits<remove_cvref_t<_Sender>>>;
+
+    template <class... _Types>
+    struct _Type_list {};
+
+    // clang-format off
+    template <class _Sender, class... _Types>
+    concept sender_of = typed_sender<_Sender> && same_as<_Type_list<_Types...>,
+        typename sender_traits<_Sender>::template value_types<_Type_list, type_identity_t> >;
+    // clang-format on
+
+    template <class _Ty, class... _Types>
+    concept _One_of = (same_as<_Ty, _Types> || ...);
+
+    namespace _Get_completion_scheduler {
+        template <_One_of<set_value_t, set_error_t, set_done_t> _Target>
+        struct _Cpo {
+            // clang-format off
+            template <sender _Sender>
+                requires tag_observable<_Cpo, _Sender> && scheduler<tag_invoke_result_t<_Cpo, _Sender>>
+            _NODISCARD constexpr auto operator()(_Sender&& _Send) const noexcept {
+                // clang-format on
+                return tag_invoke(*this, _STD as_const(_Send));
+            }
+        };
+    } // namespace _Get_completion_scheduler
+    template <_One_of<set_value_t, set_error_t, set_done_t> _Target>
+    using get_completion_scheduler_t = _Get_completion_scheduler::_Cpo<_Target>;
+
+    inline namespace _Cpos {
+        template <_One_of<set_value_t, set_error_t, set_done_t> _Target>
+        inline constexpr _Get_completion_scheduler::_Cpo<_Target> get_completion_scheduler;
+    }
+
+    // TRANSITION: Specialize for 1 argument
+    template <class... _Types>
+    struct _Just_sender {
+        tuple<_Types...> _Values;
+
+        template <template <class...> class _Tuple, template <class...> class _Variant>
+        using value_types = _Variant<_Tuple<_Types...>>;
+
+        template <template <class...> class _Variant>
+        using error_types = _Variant<exception_ptr>;
+
+        static const constexpr auto sends_done = false;
+
+        template <receiver _Receiver>
+        struct operation_state {
+            tuple<_Types...> _Values;
+            _Receiver _Rec;
+
+            friend constexpr void tag_invoke(start_t, operation_state& _State) noexcept {
+                _TRY_BEGIN
+                apply(
+                    [&_State](_Types&... _Values) { //
+                        _EXEC set_value(_STD move(_State._Rec), _STD move(_Values)...);
+                    },
+                    _State._Values);
+                _CATCH_ALL
+                _EXEC set_error(_STD move(_State._Rec), _STD current_exception());
+                _CATCH_END
+            }
+        };
+
+        // clang-format off
+        template <receiver _Receiver>
+            requires (receiver_of<_Receiver, _Types...> && (copyable<_Types> && ...))
+        _NODISCARD friend constexpr auto tag_invoke(connect_t, const _Just_sender& _Sender, _Receiver&& _Rec) noexcept(
+            (is_nothrow_copy_constructible_v<_Types> && ...) //
+            && is_nothrow_constructible_v<remove_cvref_t<_Receiver>, _Receiver>) {
+            // clang-format on
+            return operation_state<_Receiver>{_Sender._Values, _STD forward<_Receiver>(_Rec)};
+        }
+
+        // clang-format off
+        template <receiver _Receiver>
+            requires receiver_of<_Receiver, _Types...>
+        _NODISCARD friend constexpr auto tag_invoke(connect_t, _Just_sender&& _Sender, _Receiver&& _Rec) noexcept(
+            (is_nothrow_move_constructible_v<_Types> && ...)
+            && is_nothrow_constructible_v<remove_cvref_t<_Receiver>, _Receiver>) {
+            // clang-format on
+            return operation_state<_Receiver>{_STD move(_Sender._Values), _STD forward<_Receiver>(_Rec)};
+        }
+    };
+
+    template <_Movable_value... _Types>
+    _NODISCARD constexpr _Just_sender<remove_cvref_t<_Types>...> just(_Types&&... _Values) noexcept(
+        (is_nothrow_constructible_v<remove_cvref_t<_Types>, _Types> && ...)) {
+        return {_STD make_tuple(_STD forward<_Types>(_Values)...)};
+    }
+
+    template <class _Error>
+    struct _Just_error_sender {
+        _Error _Err;
+
+        template <template <class...> class _Tuple, template <class...> class _Variant>
+        using value_types = _Variant<>;
+
+        template <template <class...> class _Variant>
+        using error_types = _Variant<_Error, exception_ptr>;
+
+        static const constexpr auto sends_done = false;
+
+        template <receiver _Receiver>
+            requires receiver<_Receiver, _Error>
+        struct operation_state {
+            _Error _Err;
+            _Receiver _Rec;
+
+            friend constexpr void tag_invoke(start_t, operation_state& _State) noexcept {
+                _EXEC set_error(_STD move(_State._Rec), _STD move(_State._Err));
+            }
+        };
+
+        // clang-format off
+        template <receiver _Receiver>
+            requires receiver<_Receiver, _Error> && copyable<_Error>
+        _NODISCARD friend constexpr auto tag_invoke(connect_t, const _Just_error_sender& _Sender, _Receiver&& _Rec) //
+            noexcept(is_nothrow_copy_constructible_v<_Error> //
+                    && is_nothrow_constructible_v<remove_cvref_t<_Receiver>, _Receiver>) {
+            // clang-format on
+            return operation_state<remove_cvref_t<_Receiver>>{_Sender._Err, _STD forward<_Receiver>(_Rec)};
+        }
+
+        // clang-format off
+        template <receiver _Receiver>
+            requires receiver<_Receiver, _Error>
+        _NODISCARD friend constexpr auto tag_invoke(connect_t, _Just_error_sender&& _Sender, _Receiver&& _Rec) noexcept(
+            is_nothrow_move_constructible_v<_Error> //
+                && is_nothrow_constructible_v<remove_cvref_t<_Receiver>, _Receiver>) {
+            // clang-format on
+            return operation_state<remove_cvref_t<_Receiver>>{_STD move(_Sender._Err), _STD forward<_Receiver>(_Rec)};
+        }
+    };
+
+    template <_Movable_value _Error>
+    _NODISCARD constexpr _Just_error_sender<remove_cvref_t<_Error>> just_error(_Error&& _Err) noexcept(
+        is_nothrow_constructible_v<remove_cvref_t<_Error>, _Error>) {
+        return {_STD forward<_Error>(_Err)};
+    }
+
+    struct _Just_done_sender {
+        template <template <class...> class _Tuple, template <class...> class _Variant>
+        using value_types = _Variant<>;
+
+        template <template <class...> class _Variant>
+        using error_types = _Variant<>;
+
+        static const constexpr auto sends_done = true;
+
+        template <receiver _Receiver>
+        struct operation_state {
+            _Receiver _Rec;
+
+            friend constexpr void tag_invoke(start_t, operation_state& _State) noexcept {
+                _EXEC set_done(_STD move(_State._Rec));
+            }
+        };
+
+        template <receiver _Receiver>
+        _NODISCARD friend constexpr auto tag_invoke(connect_t, const _Just_done_sender&, _Receiver&& _Rec) noexcept(
+            is_nothrow_constructible_v<remove_cvref_t<_Receiver>, _Receiver>) {
+            return operation_state<_Receiver>{_STD forward<_Receiver>(_Rec)};
+        }
+    };
+
+    _NODISCARD constexpr _Just_done_sender just_done() noexcept {
+        return {};
+    };
+
+    template <class _Tag, class... _Args>
+    concept _Tag_invocable_to_sender = tag_invocable<_Tag, _Args...> && sender<tag_invoke_result_t<_Tag, _Args...>>;
+
+    namespace _On {
+        template <scheduler _Scheduler, receiver _InputReceiver>
+        struct _WrappedReceiver {
+            _Scheduler _Sched;
+            _InputReceiver _Input_receiver;
+
+            friend constexpr void tag_invoke(set_done_t, _WrappedReceiver _Wrapped_receiver) noexcept {
+                _EXEC set_done(_STD move(_Wrapped_receiver._Input_receiver));
+            }
+            template <class _Error>
+            friend constexpr void tag_invoke(set_error_t, _WrappedReceiver _Wrapped_receiver, _Error&& _Err) noexcept {
+                _EXEC set_error(_STD move(_Wrapped_receiver._Input_receiver), _STD forward<_Error>(_Err));
+            }
+            template <class... _ArgTys>
+            friend constexpr void tag_invoke(
+                set_value_t, _WrappedReceiver _Wrapped_receiver, _ArgTys&&... _Args) noexcept {
+                _EXEC set_value(_STD move(_Wrapped_receiver._Input_receiver), _STD forward<_ArgTys>(_Args)...);
+            }
+            _NODISCARD friend constexpr auto tag_invoke(
+                get_scheduler_t, const _WrappedReceiver& _Wrapped_receiver) noexcept {
+                return _Wrapped_receiver._Sched;
+            }
+        };
+
+        template <scheduler _Scheduler, sender _InputSender, receiver _InputReceiver>
+        struct _InnerReceiver {
+            using _WrappedReceiver_t = _WrappedReceiver<_Scheduler, _InputReceiver>;
+
+            // Clang complains about incomplete type, so for now no _OutputSenderState*
+            _WrappedReceiver_t* _Wrapped_receiver;
+            _InputSender* _Input_sender;
+            invoke_result_t<connect_t, _InputSender, _WrappedReceiver_t>* _Op_state3;
+
+            friend constexpr void tag_invoke(set_done_t, _InnerReceiver _Inner_receiver) noexcept {
+                _EXEC set_done(_STD move(_Inner_receiver._Wrapped_receiver->_Input_receiver));
+            }
+            template <class _Error>
+            friend constexpr void tag_invoke(set_error_t, _InnerReceiver _Inner_receiver, _Error&& _Err) noexcept {
+                _EXEC set_error(
+                    _STD move(_Inner_receiver._Wrapped_receiver->_Input_receiver), _STD forward<_Error>(_Err));
+            }
+            friend constexpr void tag_invoke(set_value_t, _InnerReceiver _Inner_receiver) noexcept {
+                auto* _Wrapped_receiver = _Inner_receiver._Wrapped_receiver;
+                _TRY_BEGIN
+                // *this is stored inside of `_Op_state2` so the call below will invalidate it. store the members
+                auto* _Input_sender = _Inner_receiver._Input_sender;
+                auto* _Op_state3    = _Inner_receiver._Op_state3;
+                _STD construct_at(_Op_state3, _EXEC connect(_STD move(*_Input_sender), _STD move(*_Wrapped_receiver)));
+                _EXEC start(*_Op_state3);
+                _CATCH_ALL
+                _EXEC set_error(_STD move(_Wrapped_receiver->_Input_receiver), _STD current_exception());
+                _CATCH_END
+            }
+        };
+
+        template <scheduler _Scheduler, sender _InputSender, receiver _InputReceiver>
+        struct _OutputSenderState {
+            using _WrappedReceiver_t = _WrappedReceiver<_Scheduler, _InputReceiver>;
+            using _InnerReceiver_t   = _InnerReceiver<_Scheduler, _InputSender, _InputReceiver>;
+
+            _WrappedReceiver_t _Wrapped_receiver;
+            _InputSender _Input_sender;
+            union {
+                invoke_result_t<connect_t, invoke_result_t<schedule_t, _Scheduler>, _InnerReceiver_t> _Op_state2;
+                invoke_result_t<connect_t, _InputSender, _WrappedReceiver_t> _Op_state3;
+            };
+
+            explicit constexpr _OutputSenderState(_WrappedReceiver_t _Wrapped_receiver_, _InputSender _Input_sender_)
+                : _Wrapped_receiver(_STD move(_Wrapped_receiver_)), _Input_sender(_STD move(_Input_sender_)),
+                  _Op_state2(_EXEC connect(_EXEC schedule(_Wrapped_receiver._Sched),
+                      _InnerReceiver_t{_STD addressof(_Wrapped_receiver), _STD addressof(_Input_sender),
+                          _STD addressof(_Op_state3)})) {}
+
+            friend constexpr void tag_invoke(start_t, _OutputSenderState& _State) noexcept {
+                _EXEC start(_State._Op_state2);
+            }
+        };
+
+        template <scheduler _Scheduler, sender _InputSender>
+        struct _OutputSender {
+            _Scheduler _Sched;
+            _InputSender _Input_sender;
+
+            template <receiver _InputReceiver>
+            _NODISCARD friend constexpr auto
+                tag_invoke(connect_t, _OutputSender _Output_sender, _InputReceiver&& _Input_receiver) noexcept(
+                    is_nothrow_move_constructible_v<_Scheduler>&& is_nothrow_move_constructible_v<_InputSender>&&
+                        is_nothrow_constructible_v<remove_cvref_t<_InputReceiver>, _InputReceiver>) {
+                return _OutputSenderState<_Scheduler, _InputSender, _InputReceiver>{
+                    _WrappedReceiver<_Scheduler, _InputReceiver>{
+                        _STD move(_Output_sender._Sched), _STD forward<_InputReceiver>(_Input_receiver)},
+                    _STD move(_Output_sender._Input_sender)};
+            }
+
+            template <_One_of<set_value_t, set_error_t, set_done_t> _Target>
+            _NODISCARD friend constexpr auto tag_invoke(
+                get_completion_scheduler_t<_Target>, const _OutputSender& _Output_sender) noexcept requires
+                tag_observable<get_completion_scheduler_t<_Target>, _InputSender> {
+                return tag_invoke(get_completion_scheduler<_Target>, _Output_sender._Input_sender);
+            }
+        };
+
+        struct _Cpo {
+            template <scheduler _Scheduler, sender _InputSender>
+            _NODISCARD constexpr auto operator()(_Scheduler&& _Sched, _InputSender&& _Input_sender) const noexcept {
+                if constexpr (_Tag_invocable_to_sender<_Cpo, _Scheduler, _InputSender>) {
+                    return tag_invoke(
+                        *this, _STD forward<_Scheduler>(_Sched), _STD forward<_InputSender>(_Input_sender));
+                } else {
+                    return _OutputSender<_Scheduler, _InputSender>{
+                        _STD forward<_Scheduler>(_Sched), _STD forward<_InputSender>(_Input_sender)};
+                }
+            }
+        };
+    } // namespace _On
+    using on_t = _On::_Cpo;
+
+    inline namespace _Cpos {
+        inline constexpr _On::_Cpo on;
+    }
+
+    template <scheduler _Scheduler, sender _InputSender>
+    struct sender_traits<_On::_OutputSender<_Scheduler, _InputSender>>
+        : decltype(_Get_sender_traits_derived<_InputSender>()) {};
+} // namespace execution
+#endif // __cpp_lib_executors
 _STD_END
 #pragma pop_macro("new")
 _STL_RESTORE_CLANG_WARNINGS
diff --git a/stl/inc/ranges b/stl/inc/ranges
index 3ae0270bd0e..ff199794ba8 100644
--- a/stl/inc/ranges
+++ b/stl/inc/ranges
@@ -60,111 +60,6 @@ namespace ranges {
     template <bool _IsWrapped, class _Ty>
     using _Maybe_wrapped = conditional_t<_IsWrapped, _Ty, _Unwrapped_t<_Ty>>;
 
-    namespace _Pipe {
-        // clang-format off
-        template <class _Left, class _Right>
-        concept _Can_pipe = requires(_Left&& __l, _Right&& __r) {
-            static_cast<_Right&&>(__r)(static_cast<_Left&&>(__l));
-        };
-
-        template <class _Left, class _Right>
-        concept _Can_compose = constructible_from<remove_cvref_t<_Left>, _Left>
-            && constructible_from<remove_cvref_t<_Right>, _Right>;
-        // clang-format on
-
-        template <class, class>
-        struct _Pipeline;
-
-        template <class _Derived>
-        struct _Base {
-            template <class _Other>
-                requires _Can_compose<_Derived, _Other>
-            constexpr auto operator|(_Base<_Other>&& __r) && noexcept(
-                noexcept(_Pipeline{static_cast<_Derived&&>(*this), static_cast<_Other&&>(__r)})) {
-                _STL_INTERNAL_STATIC_ASSERT(derived_from<_Derived, _Base<_Derived>>);
-                _STL_INTERNAL_STATIC_ASSERT(derived_from<_Other, _Base<_Other>>);
-                return _Pipeline{static_cast<_Derived&&>(*this), static_cast<_Other&&>(__r)};
-            }
-
-            template <class _Other>
-                requires _Can_compose<_Derived, const _Other&>
-            constexpr auto operator|(const _Base<_Other>& __r) && noexcept(
-                noexcept(_Pipeline{static_cast<_Derived&&>(*this), static_cast<const _Other&>(__r)})) {
-                _STL_INTERNAL_STATIC_ASSERT(derived_from<_Derived, _Base<_Derived>>);
-                _STL_INTERNAL_STATIC_ASSERT(derived_from<_Other, _Base<_Other>>);
-                return _Pipeline{static_cast<_Derived&&>(*this), static_cast<const _Other&>(__r)};
-            }
-
-            template <class _Other>
-                requires _Can_compose<const _Derived&, _Other>
-            constexpr auto operator|(_Base<_Other>&& __r) const& noexcept(
-                noexcept(_Pipeline{static_cast<const _Derived&>(*this), static_cast<_Other&&>(__r)})) {
-                _STL_INTERNAL_STATIC_ASSERT(derived_from<_Derived, _Base<_Derived>>);
-                _STL_INTERNAL_STATIC_ASSERT(derived_from<_Other, _Base<_Other>>);
-                return _Pipeline{static_cast<const _Derived&>(*this), static_cast<_Other&&>(__r)};
-            }
-
-            template <class _Other>
-                requires _Can_compose<const _Derived&, const _Other&>
-            constexpr auto operator|(const _Base<_Other>& __r) const& noexcept(
-                noexcept(_Pipeline{static_cast<const _Derived&>(*this), static_cast<const _Other&>(__r)})) {
-                _STL_INTERNAL_STATIC_ASSERT(derived_from<_Derived, _Base<_Derived>>);
-                _STL_INTERNAL_STATIC_ASSERT(derived_from<_Other, _Base<_Other>>);
-                return _Pipeline{static_cast<const _Derived&>(*this), static_cast<const _Other&>(__r)};
-            }
-
-            template <_Can_pipe<const _Derived&> _Left>
-            friend constexpr auto operator|(_Left&& __l, const _Base& __r)
-#ifdef __EDG__ // TRANSITION, VSO-1222776
-                noexcept(noexcept(_STD declval<const _Derived&>()(_STD forward<_Left>(__l))))
-#else // ^^^ workaround / no workaround vvv
-                noexcept(noexcept(static_cast<const _Derived&>(__r)(_STD forward<_Left>(__l))))
-#endif // TRANSITION, VSO-1222776
-            {
-                return static_cast<const _Derived&>(__r)(_STD forward<_Left>(__l));
-            }
-
-            template <_Can_pipe<_Derived> _Left>
-            friend constexpr auto operator|(_Left&& __l, _Base&& __r)
-#ifdef __EDG__ // TRANSITION, VSO-1222776
-                noexcept(noexcept(_STD declval<_Derived>()(_STD forward<_Left>(__l))))
-#else // ^^^ workaround / no workaround vvv
-                noexcept(noexcept(static_cast<_Derived&&>(__r)(_STD forward<_Left>(__l))))
-#endif // TRANSITION, VSO-1222776
-            {
-                return static_cast<_Derived&&>(__r)(_STD forward<_Left>(__l));
-            }
-        };
-
-        template <class _Left, class _Right>
-        struct _Pipeline : _Base<_Pipeline<_Left, _Right>> {
-            /* [[no_unique_address]] */ _Left __l;
-            /* [[no_unique_address]] */ _Right __r;
-
-            template <class _Ty1, class _Ty2>
-            constexpr explicit _Pipeline(_Ty1&& _Val1, _Ty2&& _Val2) noexcept(
-                is_nothrow_convertible_v<_Ty1, _Left>&& is_nothrow_convertible_v<_Ty2, _Right>)
-                : __l(_STD forward<_Ty1>(_Val1)), __r(_STD forward<_Ty2>(_Val2)) {}
-
-            template <class _Ty>
-            _NODISCARD constexpr auto operator()(_Ty&& _Val) noexcept(
-                noexcept(__r(__l(_STD forward<_Ty>(_Val))))) requires requires {
-                __r(__l(static_cast<_Ty&&>(_Val)));
-            }
-            { return __r(__l(_STD forward<_Ty>(_Val))); }
-
-            template <class _Ty>
-            _NODISCARD constexpr auto operator()(_Ty&& _Val) const
-                noexcept(noexcept(__r(__l(_STD forward<_Ty>(_Val))))) requires requires {
-                __r(__l(static_cast<_Ty&&>(_Val)));
-            }
-            { return __r(__l(_STD forward<_Ty>(_Val))); }
-        };
-
-        template <class _Ty1, class _Ty2>
-        _Pipeline(_Ty1, _Ty2) -> _Pipeline<_Ty1, _Ty2>;
-    } // namespace _Pipe
-
     template <range _Rng, class _Derived>
     class _Cached_position : public view_interface<_Derived> {
         static_assert(_Always_false<_Rng>, "A range must be at least forward for position caching to be worthwhile.");
@@ -3906,7 +3801,7 @@ namespace ranges {
 #else // ^^^ no workaround / workaround vvv
                 auto _Match = _RANGES search(subrange{_Current, _Last}, _Parent->_Pattern);
                 auto _Begin = _Match.begin();
-                auto _End = _Match.end();
+                auto _End   = _Match.end();
 #endif // TRANSITION, DevCom-1559808
                 if (_Begin != _Last && _RANGES empty(_Parent->_Pattern)) {
                     ++_Begin;
@@ -3958,7 +3853,7 @@ namespace ranges {
 #else // ^^^ no workaround / workaround vvv
             auto _Match = _RANGES search(subrange{_It, _Last}, _Pattern);
             auto _Begin = _Match.begin();
-            auto _End = _Match.end();
+            auto _End   = _Match.end();
 #endif // TRANSITION, DevCom-1559808
             if (_Begin != _Last && _RANGES empty(_Pattern)) {
                 ++_Begin;
diff --git a/stl/inc/stop_token b/stl/inc/stop_token
index c60b5d401cf..9404d8fd6b3 100644
--- a/stl/inc/stop_token
+++ b/stl/inc/stop_token
@@ -388,6 +388,13 @@ private:
 template <class _Callback>
 stop_callback(stop_token, _Callback) -> stop_callback<_Callback>;
 
+#ifdef __cpp_lib_executors
+// TRANSITION: Implement stop token part
+class never_stop_token {
+    _NODISCARD friend constexpr bool operator==(never_stop_token, never_stop_token) = default;
+};
+#endif // __cpp_lib_executors
+
 _STD_END
 #pragma pop_macro("new")
 _STL_RESTORE_CLANG_WARNINGS
diff --git a/stl/inc/xmemory b/stl/inc/xmemory
index 013fb5b297b..30a5aa41039 100644
--- a/stl/inc/xmemory
+++ b/stl/inc/xmemory
@@ -2276,6 +2276,121 @@ constexpr _Ty* uninitialized_construct_using_allocator(_Ty* _Ptr, const _Alloc&
         _STD uses_allocator_construction_args<_Ty>(_Al, _STD forward<_Types>(_Args)...));
 }
 #endif // _HAS_CXX20
+
+#ifdef __cpp_lib_ranges
+namespace ranges::_Pipe {
+    // clang-format off
+        template <class _Left, class _Right>
+        concept _Can_pipe = requires(_Left&& __l, _Right&& __r) {
+            static_cast<_Right&&>(__r)(static_cast<_Left&&>(__l));
+        };
+
+        template <class _Left, class _Right>
+        concept _Can_compose = constructible_from<remove_cvref_t<_Left>, _Left>
+            && constructible_from<remove_cvref_t<_Right>, _Right>;
+    // clang-format on
+
+    template <class, class>
+    struct _Pipeline;
+
+    template <class _Derived>
+    struct _Base {
+        // clang-format off
+        template <class _Other>
+            requires _Can_compose<_Derived, _Other>
+        constexpr auto operator|(_Base<_Other>&& __r) && noexcept(
+            noexcept(_Pipeline{static_cast<_Derived&&>(*this), static_cast<_Other&&>(__r)})) {
+            // clang-format on
+            _STL_INTERNAL_STATIC_ASSERT(derived_from<_Derived, _Base<_Derived>>);
+            _STL_INTERNAL_STATIC_ASSERT(derived_from<_Other, _Base<_Other>>);
+            return _Pipeline{static_cast<_Derived&&>(*this), static_cast<_Other&&>(__r)};
+        }
+
+        // clang-format off
+        template <class _Other>
+            requires _Can_compose<_Derived, const _Other&>
+        constexpr auto operator|(const _Base<_Other>& __r) && noexcept(
+            noexcept(_Pipeline{static_cast<_Derived&&>(*this), static_cast<const _Other&>(__r)})) {
+            // clang-format on
+            _STL_INTERNAL_STATIC_ASSERT(derived_from<_Derived, _Base<_Derived>>);
+            _STL_INTERNAL_STATIC_ASSERT(derived_from<_Other, _Base<_Other>>);
+            return _Pipeline{static_cast<_Derived&&>(*this), static_cast<const _Other&>(__r)};
+        }
+
+        // clang-format off
+        template <class _Other>
+            requires _Can_compose<const _Derived&, _Other>
+        constexpr auto operator|(_Base<_Other>&& __r) const& noexcept(
+            noexcept(_Pipeline{static_cast<const _Derived&>(*this), static_cast<_Other&&>(__r)})) {
+            // clang-format on
+            _STL_INTERNAL_STATIC_ASSERT(derived_from<_Derived, _Base<_Derived>>);
+            _STL_INTERNAL_STATIC_ASSERT(derived_from<_Other, _Base<_Other>>);
+            return _Pipeline{static_cast<const _Derived&>(*this), static_cast<_Other&&>(__r)};
+        }
+
+        // clang-format off
+        template <class _Other>
+            requires _Can_compose<const _Derived&, const _Other&>
+        constexpr auto operator|(const _Base<_Other>& __r) const& noexcept(
+            noexcept(_Pipeline{static_cast<const _Derived&>(*this), static_cast<const _Other&>(__r)})) {
+            // clang-format on
+            _STL_INTERNAL_STATIC_ASSERT(derived_from<_Derived, _Base<_Derived>>);
+            _STL_INTERNAL_STATIC_ASSERT(derived_from<_Other, _Base<_Other>>);
+            return _Pipeline{static_cast<const _Derived&>(*this), static_cast<const _Other&>(__r)};
+        }
+
+        template <_Can_pipe<const _Derived&> _Left>
+        friend constexpr auto operator|(_Left&& __l, const _Base& __r)
+#ifdef __EDG__ // TRANSITION, VSO-1222776
+            noexcept(noexcept(_STD declval<const _Derived&>()(_STD forward<_Left>(__l))))
+#else // ^^^ workaround / no workaround vvv
+            noexcept(noexcept(static_cast<const _Derived&>(__r)(_STD forward<_Left>(__l))))
+#endif // TRANSITION, VSO-1222776
+        {
+            return static_cast<const _Derived&>(__r)(_STD forward<_Left>(__l));
+        }
+
+        template <_Can_pipe<_Derived> _Left>
+        friend constexpr auto operator|(_Left&& __l, _Base&& __r)
+#ifdef __EDG__ // TRANSITION, VSO-1222776
+            noexcept(noexcept(_STD declval<_Derived>()(_STD forward<_Left>(__l))))
+#else // ^^^ workaround / no workaround vvv
+            noexcept(noexcept(static_cast<_Derived&&>(__r)(_STD forward<_Left>(__l))))
+#endif // TRANSITION, VSO-1222776
+        {
+            return static_cast<_Derived&&>(__r)(_STD forward<_Left>(__l));
+        }
+    };
+
+    template <class _Left, class _Right>
+    struct _Pipeline : _Base<_Pipeline<_Left, _Right>> {
+        /* [[no_unique_address]] */ _Left __l;
+        /* [[no_unique_address]] */ _Right __r;
+
+        template <class _Ty1, class _Ty2>
+        constexpr explicit _Pipeline(_Ty1&& _Val1, _Ty2&& _Val2) noexcept(
+            is_nothrow_convertible_v<_Ty1, _Left>&& is_nothrow_convertible_v<_Ty2, _Right>)
+            : __l(_STD forward<_Ty1>(_Val1)), __r(_STD forward<_Ty2>(_Val2)) {}
+
+        template <class _Ty>
+        _NODISCARD constexpr auto operator()(_Ty&& _Val) noexcept(
+            noexcept(__r(__l(_STD forward<_Ty>(_Val))))) requires requires {
+            __r(__l(static_cast<_Ty&&>(_Val)));
+        }
+        { return __r(__l(_STD forward<_Ty>(_Val))); }
+
+        template <class _Ty>
+        _NODISCARD constexpr auto operator()(_Ty&& _Val) const
+            noexcept(noexcept(__r(__l(_STD forward<_Ty>(_Val))))) requires requires {
+            __r(__l(static_cast<_Ty&&>(_Val)));
+        }
+        { return __r(__l(_STD forward<_Ty>(_Val))); }
+    };
+
+    template <class _Ty1, class _Ty2>
+    _Pipeline(_Ty1, _Ty2) -> _Pipeline<_Ty1, _Ty2>;
+} // namespace ranges::_Pipe
+#endif // __cpp_lib_ranges
 _STD_END
 
 #pragma pop_macro("new")
diff --git a/stl/inc/xutility b/stl/inc/xutility
index 132dddb48be..9a7b18b30df 100644
--- a/stl/inc/xutility
+++ b/stl/inc/xutility
@@ -635,6 +635,98 @@ template <class _Fn, class... _Its>
 using indirect_result_t = invoke_result_t<_Fn, iter_reference_t<_Its>...>;
 // clang-format on
 
+#ifdef __cpp_lib_executors
+template <class _Ty>
+struct _Non_associated_entity {
+    struct _Type {
+        using type = _Ty;
+    };
+};
+
+template <class _Ty>
+using _Unassociate = typename _Non_associated_entity<_Ty>::_Type;
+
+template <class _Ty>
+using _Reassociate = typename _Ty::type;
+
+template <class _Ty>
+concept _Non_associated = same_as<_Ty, _Unassociate<_Reassociate<_Ty>>>;
+
+
+template <class _Fn, class... _Args>
+concept _Callable = requires(_Fn&& __fn, _Args&&... __args) {
+    {_STD forward<_Fn>(__fn)(_STD forward<_Args>(__args)...)};
+};
+
+template <class _Fn, class... _Args>
+concept _Nothrow_callable = requires(_Fn&& __fn, _Args&&... __args) {
+    { _STD forward<_Fn>(__fn)(_STD forward<_Args>(__args)...) }
+    noexcept;
+};
+
+template <class _Fn, class... _Args>
+using _Call_result_t = decltype(_STD declval<_Fn>()(_STD declval<_Args>()...));
+template <auto& _Tag>
+using tag_t = decay_t<decltype(_Tag)>;
+
+namespace _Tag_invoke {
+    void tag_invoke();
+
+    template <class _Tag, class... _Args>
+    concept _Tag_invocable_no_adl = _Has_class_or_enum_type<_Tag> && requires {
+        {tag_invoke(_STD declval<_Tag>(), _STD declval<_Args>()...)};
+    };
+
+    template <class _Tag, class... _Args>
+    concept _Nothrow_tag_invocable_no_adl = _Has_class_or_enum_type<_Tag> && requires {
+        { tag_invoke(_STD declval<_Tag>(), _STD declval<_Args>()...) }
+        noexcept;
+    };
+
+    template <class _Tag, class _Arg>
+    concept _Tag_observable_no_adl = _Has_class_or_enum_type<_Tag> && requires {
+        { tag_invoke(_STD declval<_Tag>(), _STD declval<add_const_t<_Arg>>()) }
+        noexcept;
+    };
+
+    class _Cpo {
+    public:
+        template <class _Tag, class... _Args>
+            requires _Tag_invocable_no_adl<_Tag, _Args...>
+        constexpr auto operator()(_Tag _Tag_, _Args&&... _Args_) const
+            noexcept(noexcept(tag_invoke(_STD declval<_Tag>(), _STD declval<_Args>()...)))
+                -> decltype(tag_invoke(_STD declval<_Tag>(), _STD declval<_Args>()...)) {
+            return tag_invoke(_STD forward<_Tag>(_Tag_), _STD forward<_Args>(_Args_)...);
+        }
+    };
+} // namespace _Tag_invoke
+
+inline namespace _Cpos {
+    inline constexpr _Tag_invoke::_Cpo tag_invoke;
+}
+
+template <class _Tag, class... _Args>
+concept tag_invocable = _Tag_invoke::_Tag_invocable_no_adl<_Tag, _Args...>;
+
+template <class _Tag, class... _Args>
+concept nothrow_tag_invocable = _Tag_invoke::_Nothrow_tag_invocable_no_adl<_Tag, _Args...>;
+
+template <class _Tag, class _Arg>
+concept tag_observable = _Tag_invoke::_Tag_observable_no_adl<_Tag, _Arg>;
+
+template <class _Tag, class... _Args>
+struct tag_invoke_result {};
+
+template <class _Tag, class... _Args>
+    requires _Tag_invoke::_Tag_invocable_no_adl<_Tag, _Args...>
+struct tag_invoke_result<_Tag, _Args...> {
+    using type = decltype(tag_invoke(_STD declval<_Tag>(), _STD declval<_Args>()...));
+};
+
+template <class _Tag, class... _Args>
+using tag_invoke_result_t = decltype(tag_invoke(_STD declval<_Tag>(), _STD declval<_Args>()...));
+#endif // __cpp_lib_executors
+
 #pragma warning(push)
 #pragma warning(disable : 5046) // '%s': Symbol involving type with internal linkage not defined
 #ifdef __clang__
diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h
index 40d7a928a07..c04af364fcf 100644
--- a/stl/inc/yvals_core.h
+++ b/stl/inc/yvals_core.h
@@ -1446,7 +1446,8 @@
 #define __cpp_lib_byteswap                          202110L
 
 #ifdef __cpp_lib_concepts
-#define __cpp_lib_expected 202202L
+#define __cpp_lib_executors 202306L
+#define __cpp_lib_expected  202202L
 #endif // __cpp_lib_concepts
 
 #define __cpp_lib_invoke_r           202106L
@@ -1537,6 +1538,7 @@ compiler option, or define _ALLOW_RTCc_IN_STL to acknowledge that you have recei
 #define _STD       ::std::
 #define _CHRONO    ::std::chrono::
 #define _RANGES    ::std::ranges::
+#define _EXEC      ::std::execution::
 
 // We use the stdext (standard extension) namespace to contain extensions that are not part of the current standard
 #define _STDEXT_BEGIN namespace stdext {
diff --git a/tests/std/test.lst b/tests/std/test.lst
index 03282d2299b..d6014db19e6 100644
--- a/tests/std/test.lst
+++ b/tests/std/test.lst
@@ -480,6 +480,11 @@ tests\P2136R3_invoke_r
 tests\P2162R2_std_visit_for_derived_classes_from_variant
 tests\P2231R1_complete_constexpr_optional_variant
 tests\P2273R3_constexpr_unique_ptr
+tests\P2300R2_executors_factories
+tests\P2300R2_executors_receiver
+tests\P2300R2_executors_scheduler
+tests\P2300R2_executors_sender
+tests\P2300R2_executors_tag_invoke
 tests\P2321R2_proxy_reference
 tests\P2401R0_conditional_noexcept_for_exchange
 tests\P2415R2_owning_view
diff --git a/tests/std/tests/P2300R2_executors_adaptors_on/env.lst b/tests/std/tests/P2300R2_executors_adaptors_on/env.lst
new file mode 100644
index 00000000000..8ac7033b206
--- /dev/null
+++ b/tests/std/tests/P2300R2_executors_adaptors_on/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P2300R2_executors_adaptors_on/test.cpp b/tests/std/tests/P2300R2_executors_adaptors_on/test.cpp
new file mode 100644
index 00000000000..d70d94ec63c
--- /dev/null
+++ b/tests/std/tests/P2300R2_executors_adaptors_on/test.cpp
@@ -0,0 +1,304 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <atomic>
+#include <cassert>
+#include <chrono>
+#include <execution>
+#include <future>
+#include <thread>
+
+using namespace std;
+using execution::receiver, execution::scheduler, execution::sender;
+
+future<void> delayed_schedule_future;
+future<void> delayed_sender_future;
+
+struct CustomError {};
+enum class CanTagInvokeOn { No, Yes };
+enum class OnStartDoes {
+    Nothing,
+    SetValues,
+    SetError,
+    SetDone,
+    SetValuesDelayed,
+    SetErrorDelayed,
+    SetDoneDelayed,
+};
+
+template <OnStartDoes OnStart>
+struct scheduler_on;
+
+template <CanTagInvokeOn TagInvokeOn, OnStartDoes OnStart = OnStartDoes::Nothing>
+struct sender_on : public execution::sender_base {
+    int _id = 0;
+
+    sender_on() = default;
+    explicit constexpr sender_on(const int id) noexcept : _id(id) {}
+    friend constexpr bool operator==(const sender_on&, const sender_on&) = default;
+
+    template <scheduler Scheduler>
+    friend constexpr auto tag_invoke(execution::on_t, Scheduler, sender_on sender) noexcept
+        requires(TagInvokeOn == CanTagInvokeOn::Yes) {
+        return sender_on{sender._id + 1};
+    }
+
+    friend constexpr auto tag_invoke(
+        execution::get_completion_scheduler_t<execution::set_value_t>, sender_on) noexcept {
+        return scheduler_on<OnStart>{};
+    }
+
+    template <receiver Receiver>
+    struct sender_on_state {
+        int _id = 0;
+        Receiver _rec;
+
+        friend constexpr void tag_invoke(execution::start_t, sender_on_state& state) noexcept {
+            ++state._id;
+            if constexpr (OnStart == OnStartDoes::SetValues) {
+                tag_invoke(execution::set_value, move(state._rec), state._id);
+            } else if constexpr (OnStart == OnStartDoes::SetError) {
+                tag_invoke(execution::set_error, move(state._rec), CustomError{});
+            } else if constexpr (OnStart == OnStartDoes::SetDone) {
+                tag_invoke(execution::set_done, move(state._rec));
+            } else if constexpr (OnStart == OnStartDoes::SetValuesDelayed) {
+                if (is_constant_evaluated()) {
+                    tag_invoke(execution::set_value, move(state._rec), state._id);
+                } else {
+                    delayed_start(state);
+                }
+            } else if constexpr (OnStart == OnStartDoes::SetErrorDelayed) {
+                if (is_constant_evaluated()) {
+                    tag_invoke(execution::set_error, move(state._rec), CustomError{});
+                } else {
+                    delayed_start(state);
+                }
+            } else if constexpr (OnStart == OnStartDoes::SetDoneDelayed) {
+                if (is_constant_evaluated()) {
+                    tag_invoke(execution::set_done, move(state._rec));
+                } else {
+                    delayed_start(state);
+                }
+            }
+        }
+
+        static void delayed_start(sender_on_state& state) noexcept {
+            delayed_sender_future = async([&state]() {
+                this_thread::sleep_for(1000ms);
+                if constexpr (OnStart == OnStartDoes::SetValuesDelayed) {
+                    tag_invoke(execution::set_value, move(state._rec), state._id);
+                } else if constexpr (OnStart == OnStartDoes::SetErrorDelayed) {
+                    tag_invoke(execution::set_error, move(state._rec), CustomError{});
+                } else if constexpr (OnStart == OnStartDoes::SetDoneDelayed) {
+                    tag_invoke(execution::set_done, move(state._rec));
+                }
+            });
+        }
+    };
+
+    template <receiver Receiver>
+    friend constexpr auto tag_invoke(
+        execution::connect_t, sender_on<TagInvokeOn, OnStart> sender, Receiver&& rec) noexcept {
+        return sender_on_state<Receiver>{sender._id + 1, forward<Receiver>(rec)};
+    }
+};
+
+struct receiver_tracker {
+    int _id                        = 0;
+    bool called_set_value          = false;
+    bool called_set_error          = false;
+    bool called_set_done           = false;
+    bool has_exception_been_thrown = false;
+
+    constexpr bool nothing_called() const noexcept {
+        return !called_set_value && !called_set_error && !called_set_done;
+    }
+    constexpr bool set_value_called() const noexcept {
+        return called_set_value && !called_set_error && !called_set_done;
+    }
+    constexpr bool set_error_called() const noexcept {
+        return !called_set_value && called_set_error && !called_set_done;
+    }
+    constexpr bool set_done_called() const noexcept {
+        return !called_set_value && !called_set_error && called_set_done;
+    }
+    constexpr bool exception_was_thrown() const noexcept {
+        return has_exception_been_thrown;
+    }
+};
+
+struct receiver_on {
+    receiver_tracker& tracker;
+
+    friend constexpr void tag_invoke(execution::set_done_t, receiver_on rec) noexcept {
+        rec.tracker.called_set_done = true;
+    }
+    friend constexpr void tag_invoke(execution::set_error_t, receiver_on rec, CustomError) noexcept {
+        rec.tracker.called_set_error = true;
+    }
+    friend void tag_invoke(execution::set_error_t, receiver_on rec, exception_ptr) noexcept {
+        rec.tracker.has_exception_been_thrown = true;
+    }
+    friend constexpr void tag_invoke(execution::set_value_t, receiver_on rec, int new_id) noexcept {
+        rec.tracker.called_set_value = true;
+        rec.tracker._id              = new_id;
+    }
+};
+static_assert(receiver<receiver_on>);
+static_assert(tag_invocable<execution::connect_t, sender_on<CanTagInvokeOn::Yes>, receiver_on>);
+static_assert(tag_invocable<execution::connect_t, sender_on<CanTagInvokeOn::No>, receiver_on>);
+
+template <OnStartDoes OnStart>
+struct scheduler_on {
+    struct sender_scheduled : public execution::sender_base {
+        int _id = 0;
+
+        sender_scheduled() = default;
+        explicit constexpr sender_scheduled(const int id) noexcept : _id(id) {}
+        friend constexpr bool operator==(const sender_scheduled& left, const sender_scheduled& right) noexcept {
+            return left._id == right._id;
+        };
+
+        template <receiver Receiver>
+        struct sender_scheduled_state {
+            Receiver _rec;
+            friend constexpr void tag_invoke(execution::start_t, sender_scheduled_state& state) noexcept {
+                if constexpr (OnStart == OnStartDoes::SetValues) {
+                    tag_invoke(execution::set_value, move(state._rec));
+                } else if constexpr (OnStart == OnStartDoes::SetError) {
+                    tag_invoke(execution::set_error, move(state._rec), CustomError{});
+                } else if constexpr (OnStart == OnStartDoes::SetDone) {
+                    tag_invoke(execution::set_done, move(state._rec));
+                } else if constexpr (OnStart == OnStartDoes::SetValuesDelayed) {
+                    if (is_constant_evaluated()) {
+                        tag_invoke(execution::set_value, move(state._rec));
+                    } else {
+                        delayed_start(state);
+                    }
+                } else if constexpr (OnStart == OnStartDoes::SetErrorDelayed) {
+                    if (is_constant_evaluated()) {
+                        tag_invoke(execution::set_error, move(state._rec), CustomError{});
+                    } else {
+                        delayed_start(state);
+                    }
+                } else if constexpr (OnStart == OnStartDoes::SetDoneDelayed) {
+                    if (is_constant_evaluated()) {
+                        tag_invoke(execution::set_done, move(state._rec));
+                    } else {
+                        delayed_start(state);
+                    }
+                }
+            }
+
+            static void delayed_start(sender_scheduled_state& state) noexcept {
+                delayed_schedule_future = async([&state]() {
+                    this_thread::sleep_for(1000ms);
+                    if constexpr (OnStart == OnStartDoes::SetValuesDelayed) {
+                        tag_invoke(execution::set_value, move(state._rec));
+                    } else if constexpr (OnStart == OnStartDoes::SetErrorDelayed) {
+                        tag_invoke(execution::set_error, move(state._rec), CustomError{});
+                    } else if constexpr (OnStart == OnStartDoes::SetDoneDelayed) {
+                        tag_invoke(execution::set_done, move(state._rec));
+                    }
+                });
+            }
+        };
+
+        template <receiver Receiver>
+        friend constexpr auto tag_invoke(execution::connect_t, sender_scheduled, Receiver&& rec) noexcept {
+            return sender_scheduled_state<Receiver>{forward<Receiver>(rec)};
+        }
+    };
+
+    friend constexpr bool operator==(const scheduler_on&, const scheduler_on&) noexcept = default;
+
+    friend constexpr auto tag_invoke(execution::schedule_t, scheduler_on) noexcept {
+        return sender_scheduled{};
+    }
+};
+static_assert(scheduler<scheduler_on<OnStartDoes::Nothing>>);
+static_assert(scheduler<scheduler_on<OnStartDoes::SetValues>>);
+static_assert(scheduler<scheduler_on<OnStartDoes::SetError>>);
+static_assert(scheduler<scheduler_on<OnStartDoes::SetDone>>);
+
+template <CanTagInvokeOn WithTagInvoke, OnStartDoes OnStart>
+constexpr void test_all() {
+    receiver_tracker tracker;
+    sender auto new_sender = execution::on(scheduler_on<OnStart>{}, sender_on<WithTagInvoke, OnStart>{});
+    static_assert(same_as<decltype(execution::get_completion_scheduler<execution::set_value_t>(as_const(new_sender))),
+        scheduler_on<OnStart>>);
+
+    execution::operation_state auto new_state = execution::connect(new_sender, receiver_on{tracker});
+
+    if constexpr (WithTagInvoke == CanTagInvokeOn::Yes) {
+        assert(new_sender._id == 1);
+        assert(new_state._id == 2);
+    }
+
+    execution::start(new_state);
+    if constexpr (OnStart == OnStartDoes::SetValuesDelayed || OnStart == OnStartDoes::SetErrorDelayed
+                  || OnStart == OnStartDoes::SetDoneDelayed) {
+        if (!is_constant_evaluated()) {
+            if constexpr (WithTagInvoke == CanTagInvokeOn::No) {
+                delayed_schedule_future.wait();
+            }
+            delayed_sender_future.wait();
+        }
+    }
+
+    if constexpr (WithTagInvoke == CanTagInvokeOn::Yes) {
+        assert(new_state._id == 3);
+    }
+
+    if constexpr (OnStart == OnStartDoes::Nothing) {
+        assert(tracker.nothing_called());
+    } else if constexpr (OnStart == OnStartDoes::SetValues) {
+        assert(tracker.set_value_called());
+    } else if constexpr (OnStart == OnStartDoes::SetError) {
+        assert(tracker.set_error_called());
+    } else if constexpr (OnStart == OnStartDoes::SetDone) {
+        assert(tracker.set_done_called());
+    } else if constexpr (OnStart == OnStartDoes::SetValuesDelayed) {
+        assert(tracker.set_value_called());
+    } else if constexpr (OnStart == OnStartDoes::SetErrorDelayed) {
+        assert(tracker.set_error_called());
+    } else if constexpr (OnStart == OnStartDoes::SetDoneDelayed) {
+        assert(tracker.set_done_called());
+    }
+
+    if constexpr (WithTagInvoke == CanTagInvokeOn::Yes) {
+        static_assert(same_as<decltype(new_sender), sender_on<WithTagInvoke, OnStart>>);
+        static_assert(same_as<decltype(new_state),
+            typename sender_on<WithTagInvoke, OnStart>::template sender_on_state<receiver_on>>);
+    } else {
+        static_assert(same_as<decltype(new_sender),
+            execution::_On::_OutputSender<scheduler_on<OnStart>, sender_on<CanTagInvokeOn::No, OnStart>>>);
+        static_assert(same_as<decltype(new_state), execution::_On::_OutputSenderState<scheduler_on<OnStart>,
+                                                       sender_on<CanTagInvokeOn::No, OnStart>, receiver_on>>);
+    }
+}
+
+constexpr bool test_on() {
+    test_all<CanTagInvokeOn::Yes, OnStartDoes::Nothing>();
+    test_all<CanTagInvokeOn::Yes, OnStartDoes::SetValues>();
+    test_all<CanTagInvokeOn::Yes, OnStartDoes::SetError>();
+    test_all<CanTagInvokeOn::Yes, OnStartDoes::SetDone>();
+    test_all<CanTagInvokeOn::Yes, OnStartDoes::SetValuesDelayed>();
+    test_all<CanTagInvokeOn::Yes, OnStartDoes::SetErrorDelayed>();
+    test_all<CanTagInvokeOn::Yes, OnStartDoes::SetDoneDelayed>();
+
+    test_all<CanTagInvokeOn::No, OnStartDoes::Nothing>();
+    test_all<CanTagInvokeOn::No, OnStartDoes::SetValues>();
+    test_all<CanTagInvokeOn::No, OnStartDoes::SetError>();
+    test_all<CanTagInvokeOn::No, OnStartDoes::SetDone>();
+    test_all<CanTagInvokeOn::No, OnStartDoes::SetValuesDelayed>();
+    test_all<CanTagInvokeOn::No, OnStartDoes::SetErrorDelayed>();
+    test_all<CanTagInvokeOn::No, OnStartDoes::SetDoneDelayed>();
+
+    return true;
+}
+
+int main() {
+    test_on();
+    static_assert(test_on());
+}
diff --git a/tests/std/tests/P2300R2_executors_factories/env.lst b/tests/std/tests/P2300R2_executors_factories/env.lst
new file mode 100644
index 00000000000..8ac7033b206
--- /dev/null
+++ b/tests/std/tests/P2300R2_executors_factories/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P2300R2_executors_factories/test.cpp b/tests/std/tests/P2300R2_executors_factories/test.cpp
new file mode 100644
index 00000000000..ae21a5658c4
--- /dev/null
+++ b/tests/std/tests/P2300R2_executors_factories/test.cpp
@@ -0,0 +1,154 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cassert>
+#include <concepts>
+#include <execution>
+#include <tuple>
+using namespace std;
+using execution::connect, execution::operation_state, execution::receiver_of, execution::sender_of, execution::start,
+    execution::typed_sender;
+
+struct Tracker {
+    bool set_values_called = false;
+    bool set_error_called  = false;
+    bool set_done_called   = false;
+};
+struct Dummy {};
+struct CustomError {};
+
+enum class DoesThrowOnSetValue : bool { No, Yes };
+template <DoesThrowOnSetValue ThrowOnSetValue, class... Types>
+struct test_receiver {
+    constexpr test_receiver(Tracker& tracker) noexcept : _tracker(tracker) {}
+    friend constexpr auto tag_invoke(execution::set_done_t, test_receiver rec) noexcept {
+        rec._tracker.set_done_called = true;
+    }
+    friend auto tag_invoke(execution::set_error_t, test_receiver rec, exception_ptr) noexcept {
+        rec._tracker.set_error_called = true;
+    }
+    friend constexpr auto tag_invoke(execution::set_error_t, test_receiver rec, CustomError) noexcept {
+        rec._tracker.set_error_called = true;
+    }
+    friend constexpr auto tag_invoke(execution::set_value_t, test_receiver rec, Types...) noexcept(
+        ThrowOnSetValue == DoesThrowOnSetValue::No) {
+        rec._tracker.set_values_called = true;
+        if constexpr (ThrowOnSetValue == DoesThrowOnSetValue::Yes) {
+            throw 42;
+        }
+    }
+
+    struct fake_operation_state {
+        friend constexpr void tag_invoke(execution::start_t, fake_operation_state&) noexcept {}
+    };
+
+    Tracker& _tracker;
+};
+template <class... Types>
+using nothrow_receiver = test_receiver<DoesThrowOnSetValue::No, Types...>;
+template <class... Types>
+using throws_on_set_values_receiver = test_receiver<DoesThrowOnSetValue::Yes, Types...>;
+
+static_assert(receiver_of<nothrow_receiver<int>, int>);
+static_assert(operation_state<nothrow_receiver<int>::fake_operation_state>);
+static_assert(receiver_of<throws_on_set_values_receiver<int>, int>);
+static_assert(operation_state<throws_on_set_values_receiver<int>::fake_operation_state>);
+
+constexpr bool test_just() {
+    {
+        Tracker tracker;
+        const sender_of<int> auto sender = execution::just(5);
+        operation_state auto state       = connect(sender, nothrow_receiver<int>{tracker});
+        assert(!tracker.set_values_called);
+        start(state);
+        assert(tracker.set_values_called);
+
+        static_assert(!invocable<execution::connect_t, decltype(sender), nothrow_receiver<Dummy>>);
+    }
+
+    {
+        Tracker tracker;
+        operation_state auto state = connect(execution::just(5), nothrow_receiver<int>{tracker});
+        assert(!tracker.set_values_called);
+        start(state);
+        assert(tracker.set_values_called);
+    }
+
+    {
+        Tracker tracker;
+        const sender_of<int, Dummy> auto sender = execution::just(5, Dummy{});
+        operation_state auto state              = connect(sender, nothrow_receiver<int, Dummy>{tracker});
+        assert(!tracker.set_values_called);
+        start(state);
+        assert(tracker.set_values_called);
+
+        static_assert(!invocable<execution::connect_t, decltype(sender), nothrow_receiver<Dummy, int>>);
+    }
+
+    if (!is_constant_evaluated()) {
+        Tracker tracker;
+        operation_state auto state = connect(execution::just(5), throws_on_set_values_receiver<int>{tracker});
+        assert(!tracker.set_values_called);
+        assert(!tracker.set_error_called);
+        start(state);
+        assert(tracker.set_values_called);
+        assert(tracker.set_error_called);
+    }
+
+    return true;
+}
+
+constexpr bool test_just_error() {
+    {
+        Tracker tracker;
+        typed_sender auto sender   = execution::just_error(CustomError{});
+        operation_state auto state = connect(sender, nothrow_receiver<>{tracker});
+        assert(!tracker.set_error_called);
+        start(state);
+        assert(tracker.set_error_called);
+    }
+
+    {
+        Tracker tracker;
+        operation_state auto state = connect(execution::just_error(CustomError{}), nothrow_receiver<>{tracker});
+        assert(!tracker.set_error_called);
+        start(state);
+        assert(tracker.set_error_called);
+    }
+
+    { // Ensure that we cannot connect a receiver with the wrong error type
+        typed_sender auto sender = execution::just_error(Dummy{});
+        static_assert(!invocable<execution::connect_t, decltype(sender), nothrow_receiver<>>);
+    }
+
+    return true;
+}
+
+constexpr bool test_just_done() {
+    {
+        Tracker tracker;
+        typed_sender auto sender   = execution::just_done();
+        operation_state auto state = connect(sender, nothrow_receiver<>{tracker});
+        assert(!tracker.set_done_called);
+        start(state);
+        assert(tracker.set_done_called);
+    }
+
+    {
+        Tracker tracker;
+        operation_state auto state = connect(execution::just_done(), nothrow_receiver<>{tracker});
+        assert(!tracker.set_done_called);
+        start(state);
+        assert(tracker.set_done_called);
+    }
+
+    return true;
+}
+
+int main() {
+    test_just();
+    static_assert(test_just());
+
+    test_just_error();
+    static_assert(test_just_error());
+}
diff --git a/tests/std/tests/P2300R2_executors_receiver/env.lst b/tests/std/tests/P2300R2_executors_receiver/env.lst
new file mode 100644
index 00000000000..18e2d7c71ec
--- /dev/null
+++ b/tests/std/tests/P2300R2_executors_receiver/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\concepts_latest_matrix.lst
diff --git a/tests/std/tests/P2300R2_executors_receiver/test.compile.pass.cpp b/tests/std/tests/P2300R2_executors_receiver/test.compile.pass.cpp
new file mode 100644
index 00000000000..2366ec5b9ba
--- /dev/null
+++ b/tests/std/tests/P2300R2_executors_receiver/test.compile.pass.cpp
@@ -0,0 +1,379 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cassert>
+#include <execution>
+#include <stop_token>
+using namespace std;
+
+namespace set_value {
+    enum class IsMovable : bool { No, Yes };
+
+    template <IsMovable Movable = IsMovable::Yes>
+    struct tester {
+        tester()                                            = default;
+        tester(const tester&) noexcept                      = default;
+        tester(tester&&) requires(Movable == IsMovable::No) = delete;
+
+        friend constexpr auto tag_invoke(execution::set_value_t, tester, int) noexcept {
+            return true;
+        }
+    };
+
+    // Test whether we can tag invoke
+    static_assert(invocable<execution::set_value_t, tester<IsMovable::Yes>, int>);
+    static_assert(!invocable<execution::set_value_t, tester<IsMovable::No>, int>);
+
+    // Ensure we got the right number of arguments
+    static_assert(!invocable<execution::set_value_t, tester<IsMovable::Yes>, int, double>);
+    static_assert(!invocable<execution::set_value_t, tester<IsMovable::Yes>>);
+
+    // Actually call it
+    static_assert(execution::set_value(tester<IsMovable::Yes>{}, 5));
+} // namespace set_value
+
+namespace set_error {
+    enum class IsMovable : bool { No, Yes };
+    struct Error {};
+
+    template <IsMovable Movable = IsMovable::Yes>
+    struct tester {
+        tester()                                            = default;
+        tester(const tester&) noexcept                      = default;
+        tester(tester&&) requires(Movable == IsMovable::No) = delete;
+
+        friend constexpr auto tag_invoke(execution::set_error_t, tester, Error) noexcept {
+            return true;
+        }
+    };
+
+    // Test whether we can tag invoke
+    static_assert(invocable<execution::set_error_t, tester<IsMovable::Yes>, Error>);
+    static_assert(!invocable<execution::set_error_t, tester<IsMovable::No>, Error>);
+
+    // Ensure we got the right number of arguments
+    static_assert(!invocable<execution::set_error_t, tester<IsMovable::Yes>, Error, double>);
+    static_assert(!invocable<execution::set_error_t, tester<IsMovable::Yes>>);
+
+    // Actually call it
+    static_assert(execution::set_error(tester<IsMovable::Yes>{}, Error{}));
+} // namespace set_error
+
+namespace set_done {
+    enum class IsMovable : bool { No, Yes };
+    struct Error {};
+
+    template <IsMovable Movable = IsMovable::Yes>
+    struct tester {
+        tester()                                            = default;
+        tester(const tester&) noexcept                      = default;
+        tester(tester&&) requires(Movable == IsMovable::No) = delete;
+
+        friend constexpr auto tag_invoke(execution::set_done_t, tester) noexcept {
+            return true;
+        }
+    };
+
+    // Test whether we can tag invoke
+    static_assert(invocable<execution::set_done_t, tester<IsMovable::Yes>>);
+    static_assert(!invocable<execution::set_done_t, tester<IsMovable::No>>);
+
+    // Ensure we got the right number of arguments
+    static_assert(!invocable<execution::set_done_t, tester<IsMovable::Yes>, int>);
+
+    // Actually call it
+    static_assert(execution::set_done(tester<IsMovable::Yes>{}));
+} // namespace set_done
+
+namespace receiver {
+    enum class IsMovable : bool { No, Yes };
+    enum class HasSetDone : bool { No, Yes };
+    enum class HasSetError : bool { No, Yes };
+    struct Error {};
+    struct OtherError {};
+
+    template <IsMovable Movable = IsMovable::Yes, HasSetDone SetDone = HasSetDone::Yes,
+        HasSetError SetError = HasSetError::Yes>
+    struct tester {
+        tester()                                            = default;
+        tester(const tester&) noexcept                      = default;
+        tester(tester&&) requires(Movable == IsMovable::No) = delete;
+
+        friend constexpr auto tag_invoke(execution::set_done_t, tester) noexcept requires(SetDone == HasSetDone::Yes) {
+            return true;
+        }
+
+        friend constexpr auto tag_invoke(execution::set_error_t, tester, Error) noexcept
+            requires(SetError == HasSetError::Yes) {
+            return true;
+        }
+    };
+
+    // No move no receiver
+    static_assert(execution::receiver<tester<IsMovable::Yes>, Error>);
+    static_assert(!execution::receiver<tester<IsMovable::No>, Error>);
+
+    // Must have set_done
+    static_assert(!execution::receiver<tester<IsMovable::Yes, HasSetDone::No>, Error>);
+
+    // Must have set_error
+    static_assert(!execution::receiver<tester<IsMovable::Yes, HasSetDone::Yes, HasSetError::No>, Error>);
+
+    // Must pass the right error set_error
+    static_assert(!execution::receiver<tester<IsMovable::Yes>, OtherError>);
+} // namespace receiver
+
+namespace receiver_of {
+    enum class IsMovable : bool { No, Yes };
+    enum class HasSetDone : bool { No, Yes };
+    enum class HasSetError { Yes, No, Custom };
+    enum class HasSetCustomError : bool { No, Yes };
+    enum class HasSetValue : bool { No, Yes };
+    class CustomError {};
+
+    template <IsMovable Movable = IsMovable::Yes, HasSetDone SetDone = HasSetDone::Yes,
+        HasSetError SetError = HasSetError::Yes, HasSetValue SetValue = HasSetValue::Yes>
+    struct tester {
+        tester()                                            = default;
+        tester(const tester&) noexcept                      = default;
+        tester(tester&&) requires(Movable == IsMovable::No) = delete;
+
+        friend constexpr auto tag_invoke(execution::set_done_t, tester) noexcept requires(SetDone == HasSetDone::Yes) {
+            return true;
+        }
+
+        friend auto tag_invoke(execution::set_error_t, tester, exception_ptr) noexcept
+            requires(SetError == HasSetError::Yes) {
+            return true;
+        }
+
+        friend constexpr auto tag_invoke(execution::set_error_t, tester, CustomError) noexcept
+            requires(SetError == HasSetError::Custom) {
+            return true;
+        }
+
+        friend constexpr auto tag_invoke(execution::set_value_t, tester, int) noexcept
+            requires(SetValue == HasSetValue::Yes) {
+            return true;
+        }
+    };
+
+    // No move no receiver
+    static_assert(execution::receiver_of<tester<IsMovable::Yes>, int>);
+    static_assert(!execution::receiver_of<tester<IsMovable::No>, int>);
+
+    // Must have set_done
+    static_assert(!execution::receiver_of<tester<IsMovable::Yes, HasSetDone::No>, int>);
+
+    // Must have set_error
+    static_assert(!execution::receiver_of<tester<IsMovable::Yes, HasSetDone::Yes, HasSetError::No>, int>);
+
+    // Must have right set_error
+    static_assert(!execution::receiver_of<tester<IsMovable::Yes, HasSetDone::Yes, HasSetError::Custom>, int>);
+
+    // Must have set_value
+    static_assert(
+        !execution::receiver_of<tester<IsMovable::Yes, HasSetDone::Yes, HasSetError::Yes, HasSetValue::No>, int>);
+
+    // Must have the right set_value
+    static_assert(!execution::receiver_of<tester<IsMovable::Yes>, nullptr_t>);
+} // namespace receiver_of
+
+namespace get_scheduler {
+    enum class IsMovable : bool { No, Yes };
+    enum class HasSetDone : bool { No, Yes };
+    enum class HasSetError : bool { No, Yes };
+    enum class IsNothrowObservable : bool { No, Yes };
+    enum class IsConstObservable : bool { No, Yes };
+
+    template <IsMovable Movable = IsMovable::Yes, HasSetDone SetDone = HasSetDone::Yes,
+        HasSetError SetError = HasSetError::Yes, IsNothrowObservable NothrowObservable = IsNothrowObservable::Yes,
+        IsConstObservable ConstObservable = IsConstObservable::Yes>
+    struct tester {
+        tester()                                            = default;
+        tester(const tester&) noexcept                      = default;
+        tester(tester&&) requires(Movable == IsMovable::No) = delete;
+
+        friend constexpr auto tag_invoke(execution::set_done_t, tester) noexcept requires(SetDone == HasSetDone::Yes) {
+            return true;
+        }
+
+        friend auto tag_invoke(execution::set_error_t, tester, exception_ptr) noexcept
+            requires(SetError == HasSetError::Yes) {
+            return true;
+        }
+
+        friend constexpr auto tag_invoke(execution::get_scheduler_t, const tester) noexcept(
+            NothrowObservable == IsNothrowObservable::Yes) requires(ConstObservable == IsConstObservable::Yes) {
+            return true;
+        }
+
+        friend constexpr auto tag_invoke(execution::get_scheduler_t, tester&&) noexcept(
+            NothrowObservable == IsNothrowObservable::Yes) requires(ConstObservable == IsConstObservable::No) {
+            return false;
+        }
+    };
+
+    // Ensure we require a receiver
+    static_assert(invocable<execution::get_scheduler_t, tester<IsMovable::Yes>>);
+    static_assert(!invocable<execution::get_scheduler_t, tester<IsMovable::No>>);
+    static_assert(!invocable<execution::get_scheduler_t, tester<IsMovable::Yes, HasSetDone::No>>);
+    static_assert(!invocable<execution::get_scheduler_t, tester<IsMovable::Yes, HasSetDone::Yes, HasSetError::No>>);
+
+    // Ensure we satisfy observable
+    static_assert(!invocable<execution::get_scheduler_t,
+                  tester<IsMovable::Yes, HasSetDone::Yes, HasSetError::Yes, IsNothrowObservable::No>>);
+    static_assert(!invocable<execution::get_scheduler_t, tester<IsMovable::Yes, HasSetDone::Yes, HasSetError::Yes,
+                                                             IsNothrowObservable::Yes, IsConstObservable::No>>);
+
+    // Actually call it
+    static_assert(execution::get_scheduler(tester<IsMovable::Yes>{}));
+} // namespace get_scheduler
+
+namespace get_allocator {
+    enum class IsMovable : bool { No, Yes };
+    enum class HasSetDone : bool { No, Yes };
+    enum class HasSetError : bool { No, Yes };
+    enum class IsNothrowObservable : bool { No, Yes };
+    enum class IsConstObservable : bool { No, Yes };
+
+    template <IsMovable Movable = IsMovable::Yes, HasSetDone SetDone = HasSetDone::Yes,
+        HasSetError SetError = HasSetError::Yes, IsNothrowObservable NothrowObservable = IsNothrowObservable::Yes,
+        IsConstObservable ConstObservable = IsConstObservable::Yes>
+    struct tester {
+        tester()                                            = default;
+        tester(const tester&) noexcept                      = default;
+        tester(tester&&) requires(Movable == IsMovable::No) = delete;
+
+        friend constexpr auto tag_invoke(execution::set_done_t, tester) noexcept requires(SetDone == HasSetDone::Yes) {
+            return true;
+        }
+
+        friend auto tag_invoke(execution::set_error_t, tester, exception_ptr) noexcept
+            requires(SetError == HasSetError::Yes) {
+            return true;
+        }
+
+        friend constexpr auto tag_invoke(execution::get_allocator_t, const tester) noexcept(
+            NothrowObservable == IsNothrowObservable::Yes) requires(ConstObservable == IsConstObservable::Yes) {
+            return true;
+        }
+
+        friend constexpr auto tag_invoke(execution::get_allocator_t, tester&&) noexcept(
+            NothrowObservable == IsNothrowObservable::Yes) requires(ConstObservable == IsConstObservable::No) {
+            return false;
+        }
+    };
+
+    // Ensure we require a receiver
+    static_assert(invocable<execution::get_allocator_t, tester<IsMovable::Yes>>);
+    static_assert(!invocable<execution::get_allocator_t, tester<IsMovable::No>>);
+    static_assert(!invocable<execution::get_allocator_t, tester<IsMovable::Yes, HasSetDone::No>>);
+    static_assert(!invocable<execution::get_allocator_t, tester<IsMovable::Yes, HasSetDone::Yes, HasSetError::No>>);
+
+    // Ensure we satisfy observable
+    static_assert(!invocable<execution::get_allocator_t,
+                  tester<IsMovable::Yes, HasSetDone::Yes, HasSetError::Yes, IsNothrowObservable::No>>);
+    static_assert(!invocable<execution::get_allocator_t, tester<IsMovable::Yes, HasSetDone::Yes, HasSetError::Yes,
+                                                             IsNothrowObservable::Yes, IsConstObservable::No>>);
+
+    // Actually call it
+    static_assert(execution::get_allocator(tester<IsMovable::Yes>{}));
+} // namespace get_allocator
+
+namespace get_stop_token {
+    enum class IsMovable : bool { No, Yes };
+    enum class HasSetDone : bool { No, Yes };
+    enum class HasSetError : bool { No, Yes };
+    enum class IsNothrowObservable : bool { No, Yes };
+    enum class IsConstObservable : bool { No, Yes };
+
+    template <IsMovable Movable = IsMovable::Yes, HasSetDone SetDone = HasSetDone::Yes,
+        HasSetError SetError = HasSetError::Yes, IsNothrowObservable NothrowObservable = IsNothrowObservable::Yes,
+        IsConstObservable ConstObservable = IsConstObservable::Yes>
+    struct tester {
+        tester()                                            = default;
+        tester(const tester&) noexcept                      = default;
+        tester(tester&&) requires(Movable == IsMovable::No) = delete;
+
+        friend constexpr auto tag_invoke(execution::set_done_t, tester) noexcept requires(SetDone == HasSetDone::Yes) {
+            return true;
+        }
+
+        friend auto tag_invoke(execution::set_error_t, tester, exception_ptr) noexcept
+            requires(SetError == HasSetError::Yes) {
+            return true;
+        }
+
+        friend constexpr auto tag_invoke(execution::get_stop_token_t, const tester) noexcept(
+            NothrowObservable == IsNothrowObservable::Yes) requires(ConstObservable == IsConstObservable::Yes) {
+            return true;
+        }
+
+        friend constexpr auto tag_invoke(execution::get_stop_token_t, tester&&) noexcept(
+            NothrowObservable == IsNothrowObservable::Yes) requires(ConstObservable == IsConstObservable::No) {
+            return false;
+        }
+    };
+
+    // Ensure we require a receiver
+    static_assert(invocable<execution::get_stop_token_t, tester<IsMovable::Yes>>);
+    static_assert(!invocable<execution::get_stop_token_t, tester<IsMovable::No>>);
+    static_assert(!invocable<execution::get_stop_token_t, tester<IsMovable::Yes, HasSetDone::No>>);
+    static_assert(!invocable<execution::get_stop_token_t, tester<IsMovable::Yes, HasSetDone::Yes, HasSetError::No>>);
+
+    // Ensure that when we are not observable, we return never_stop_token
+    static_assert(
+        execution::get_stop_token(tester<IsMovable::Yes, HasSetDone::Yes, HasSetError::Yes, IsNothrowObservable::No>{})
+        == never_stop_token{});
+    static_assert(execution::get_stop_token(tester<IsMovable::Yes, HasSetDone::Yes, HasSetError::Yes,
+                      IsNothrowObservable::Yes, IsConstObservable::No>{})
+                  == never_stop_token{});
+
+    // Actually call it
+    static_assert(execution::get_stop_token(tester<IsMovable::Yes>{}));
+} // namespace get_stop_token
+
+namespace operation_state {
+    enum class IsDestructible : bool { No, Yes };
+    enum class HasStart { No, LValue, LValueMayThrow, RValue, RValueMayThrow };
+
+    template <IsDestructible Destructible = IsDestructible::Yes, HasStart Start = HasStart::LValue>
+    struct tester {
+        tester() = default;
+        ~tester() noexcept(Destructible == IsDestructible::Yes){};
+
+        friend constexpr void tag_invoke(execution::start_t, tester&) noexcept requires(Start == HasStart::LValue) {}
+        friend constexpr void tag_invoke(execution::start_t, tester&) requires(Start == HasStart::LValueMayThrow) {}
+
+        friend constexpr void tag_invoke(execution::start_t, tester&&) noexcept requires(Start == HasStart::RValue) {}
+        friend constexpr void tag_invoke(execution::start_t, tester&&) requires(Start == HasStart::RValueMayThrow) {}
+    };
+
+    static_assert(execution::operation_state<tester<IsDestructible::Yes>>);
+    static_assert(invocable<execution::start_t, tester<IsDestructible::Yes>&>);
+
+    // Needs to be destructible
+    static_assert(!execution::operation_state<tester<IsDestructible::No>>);
+    static_assert(!invocable<execution::start_t, tester<IsDestructible::No>>);
+
+    // Should be an object
+    static_assert(!execution::operation_state<tester<IsDestructible::Yes>&>);
+
+    // Must have `start` operation
+    static_assert(!execution::operation_state<tester<IsDestructible::Yes, HasStart::No>>);
+    static_assert(!invocable<execution::start_t, tester<IsDestructible::Yes, HasStart::No>>);
+
+    // Must take lvalue argument for start even if tag_invocable for rvalue
+    static_assert(!execution::operation_state<tester<IsDestructible::Yes, HasStart::RValue>>);
+    static_assert(!invocable<execution::start_t, tester<IsDestructible::Yes, HasStart::RValue>>);
+    static_assert(tag_invocable<execution::start_t, tester<IsDestructible::Yes, HasStart::RValue>>);
+
+    // Must have noexcept `start_t`
+    static_assert(!execution::operation_state<tester<IsDestructible::Yes, HasStart::LValueMayThrow>>);
+    static_assert(!invocable<execution::start_t, tester<IsDestructible::Yes, HasStart::LValueMayThrow>>);
+    static_assert(!execution::operation_state<tester<IsDestructible::Yes, HasStart::RValueMayThrow>>);
+    static_assert(!invocable<execution::start_t, tester<IsDestructible::Yes, HasStart::RValueMayThrow>>);
+} // namespace operation_state
+
+int main() {}
diff --git a/tests/std/tests/P2300R2_executors_scheduler/env.lst b/tests/std/tests/P2300R2_executors_scheduler/env.lst
new file mode 100644
index 00000000000..18e2d7c71ec
--- /dev/null
+++ b/tests/std/tests/P2300R2_executors_scheduler/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\concepts_latest_matrix.lst
diff --git a/tests/std/tests/P2300R2_executors_scheduler/test.compile.pass.cpp b/tests/std/tests/P2300R2_executors_scheduler/test.compile.pass.cpp
new file mode 100644
index 00000000000..add6a9227ba
--- /dev/null
+++ b/tests/std/tests/P2300R2_executors_scheduler/test.compile.pass.cpp
@@ -0,0 +1,213 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cassert>
+#include <execution>
+using namespace std;
+
+namespace _Movable_value {
+    struct aggregate {};
+    static_assert(execution::_Movable_value<aggregate>);
+    static_assert(execution::_Movable_value<aggregate&>);
+    static_assert(execution::_Movable_value<const aggregate&>);
+    static_assert(execution::_Movable_value<const aggregate>);
+
+    struct move_only {
+        move_only(const move_only&) = delete;
+        move_only& operator=(const move_only&) = delete;
+    };
+    static_assert(!execution::_Movable_value<move_only>);
+    static_assert(!execution::_Movable_value<move_only&>);
+    static_assert(!execution::_Movable_value<const move_only&>);
+    static_assert(!execution::_Movable_value<const move_only>);
+    struct copy_only {
+        copy_only(copy_only&&) = delete;
+        copy_only& operator=(copy_only&&) = delete;
+    };
+    static_assert(!execution::_Movable_value<copy_only>);
+    static_assert(!execution::_Movable_value<copy_only&>);
+    static_assert(!execution::_Movable_value<const copy_only&>);
+    static_assert(!execution::_Movable_value<const copy_only>);
+
+    struct not_assignable {
+        not_assignable& operator=(const not_assignable&) = delete;
+        not_assignable& operator=(not_assignable&&) = delete;
+    };
+    static_assert(!execution::_Movable_value<not_assignable>);
+    static_assert(!execution::_Movable_value<not_assignable&>);
+    static_assert(!execution::_Movable_value<const not_assignable&>);
+    static_assert(!execution::_Movable_value<const not_assignable>);
+
+    struct not_constructible {
+        not_constructible(const not_constructible&) = delete;
+        not_constructible(not_constructible&&)      = delete;
+    };
+    static_assert(!execution::_Movable_value<not_constructible>);
+    static_assert(!execution::_Movable_value<not_constructible&>);
+    static_assert(!execution::_Movable_value<const not_constructible&>);
+    static_assert(!execution::_Movable_value<const not_constructible>);
+} // namespace _Movable_value
+
+namespace scheduler {
+    enum class IsCopyConstructible : bool { No, Yes };
+    enum class IsEqualityComparable : bool { No, Yes };
+    enum class IsNothrowCopyConstructible : bool { No, Yes };
+    enum class IsNothrowDestructible : bool { No, Yes };
+    enum class IsNothrowSwappable : bool { No, Yes };
+    enum class IsNothrowComparable : bool { No, Yes };
+    enum class IsSchedulable : bool { No, Yes };
+    enum class IsNothrowSchedulable : bool { No, Yes };
+
+    template <IsCopyConstructible CopyConstructible         = IsCopyConstructible::Yes,
+        IsEqualityComparable EqualityComparable             = IsEqualityComparable::Yes,
+        IsNothrowCopyConstructible NothrowCopyConstructible = IsNothrowCopyConstructible::Yes,
+        IsNothrowDestructible NothrowDestructible           = IsNothrowDestructible::Yes,
+        IsNothrowComparable NothrowComparable               = IsNothrowComparable::Yes,
+        IsSchedulable Schedulable                           = IsSchedulable::Yes,
+        IsNothrowSchedulable NothrowSchedulable             = IsNothrowSchedulable::Yes>
+    struct tester {
+        constexpr tester() = default;
+        constexpr tester(const tester&) noexcept(NothrowCopyConstructible == IsNothrowCopyConstructible::Yes) requires(
+            CopyConstructible == IsCopyConstructible::Yes)                              = default;
+        constexpr ~tester() noexcept(NothrowDestructible == IsNothrowDestructible::Yes) = default;
+        friend bool operator==(const tester&, const tester&) noexcept(NothrowComparable == IsNothrowComparable::Yes) //
+            requires(EqualityComparable == IsEqualityComparable::Yes) = default;
+
+        friend constexpr auto tag_invoke(execution::schedule_t, tester) noexcept(
+            NothrowSchedulable == IsNothrowSchedulable::Yes) requires(Schedulable == IsSchedulable::Yes) {
+            return true;
+        }
+    };
+
+    // Test basic constraints
+    static_assert(execution::scheduler<tester<IsCopyConstructible::Yes>>);
+    static_assert(!execution::scheduler<tester<IsCopyConstructible::No>>);
+    static_assert(!execution::scheduler<tester<IsCopyConstructible::Yes, IsEqualityComparable::No>>);
+    static_assert(!execution::scheduler<
+                  tester<IsCopyConstructible::Yes, IsEqualityComparable::Yes, IsNothrowCopyConstructible::No>>);
+    static_assert(!execution::scheduler<tester<IsCopyConstructible::Yes, IsEqualityComparable::Yes,
+                      IsNothrowCopyConstructible::Yes, IsNothrowDestructible::No>>);
+    static_assert(!execution::scheduler<tester<IsCopyConstructible::Yes, IsEqualityComparable::Yes,
+                      IsNothrowCopyConstructible::Yes, IsNothrowDestructible::Yes, IsNothrowComparable::No>>);
+
+    // Test remove_cvref_t
+    static_assert(execution::scheduler<tester<IsCopyConstructible::Yes>&>);
+    static_assert(execution::scheduler<const tester<IsCopyConstructible::Yes>&>);
+    static_assert(execution::scheduler<tester<IsCopyConstructible::Yes>&&>);
+    static_assert(execution::scheduler<const tester<IsCopyConstructible::Yes>&&>);
+
+    static_assert(execution::scheduler<const tester<IsCopyConstructible::Yes>>);
+    static_assert(!execution::scheduler<volatile tester<IsCopyConstructible::Yes>>);
+    static_assert(!execution::scheduler<const volatile tester<IsCopyConstructible::Yes>>);
+
+    // Scheduling
+    static_assert(execution::scheduler<tester<IsCopyConstructible::Yes>>);
+    static_assert(execution::scheduler<tester<IsCopyConstructible::Yes, IsEqualityComparable::Yes,
+            IsNothrowCopyConstructible::Yes, IsNothrowDestructible::Yes, IsNothrowComparable::Yes>>);
+    static_assert(execution::scheduler<
+        tester<IsCopyConstructible::Yes, IsEqualityComparable::Yes, IsNothrowCopyConstructible::Yes,
+            IsNothrowDestructible::Yes, IsNothrowComparable::Yes, IsSchedulable::Yes, IsNothrowSchedulable::No>>);
+    static_assert(
+        !execution::scheduler<tester<IsCopyConstructible::Yes, IsEqualityComparable::Yes,
+            IsNothrowCopyConstructible::Yes, IsNothrowDestructible::Yes, IsNothrowComparable::Yes, IsSchedulable::No>>);
+
+    // Ensure that even when there is a tag_invoke that we still bail if scheduler is not satisfied
+    static_assert(!execution::scheduler<tester<IsCopyConstructible::No>>);
+
+    // Test the actual CPOs
+    static_assert(invocable<execution::schedule_t, tester<IsCopyConstructible::Yes>>);
+    static_assert(execution::schedule(tester<IsCopyConstructible::Yes>{}));
+} // namespace scheduler
+
+namespace forward_progress_guarantee {
+    enum class IsSchedulable : bool { No, Yes };
+    enum class IsNothrowSchedulable : bool { No, Yes };
+    enum class IsConstSchedulable : bool { No, Yes };
+
+    template <IsSchedulable Schedulable         = IsSchedulable::Yes,
+        IsNothrowSchedulable NothrowSchedulable = IsNothrowSchedulable::Yes,
+        IsConstSchedulable ConstSchedulable     = IsConstSchedulable::Yes>
+    struct tester {
+        friend bool operator==(const tester&, const tester&) noexcept = default;
+        friend constexpr auto tag_invoke(execution::schedule_t, tester) noexcept
+            requires(Schedulable == IsSchedulable::Yes) {
+            return true;
+        }
+
+        friend constexpr auto tag_invoke(execution::get_forward_progress_guarantee_t, const tester) noexcept(
+            NothrowSchedulable == IsNothrowSchedulable::Yes) requires(ConstSchedulable == IsConstSchedulable::Yes) {
+            return execution::forward_progress_guarantee::concurrent;
+        }
+
+        friend constexpr auto tag_invoke(execution::get_forward_progress_guarantee_t, tester&&) noexcept(
+            NothrowSchedulable == IsNothrowSchedulable::Yes) requires(ConstSchedulable != IsConstSchedulable::Yes) {
+            return execution::forward_progress_guarantee::parallel;
+        }
+    };
+
+    static_assert(invocable<execution::get_forward_progress_guarantee_t, tester<IsSchedulable::Yes>>);
+    static_assert(execution::get_forward_progress_guarantee(tester<IsSchedulable::Yes>{})
+                  == execution::forward_progress_guarantee::concurrent);
+
+    // We need to fullfil scheduler
+    static_assert(!invocable<execution::get_forward_progress_guarantee_t, tester<IsSchedulable::No>>);
+
+    // Ensure that we fall back to execution::forward_progress_guarantee::weakly_parallel
+    static_assert(execution::get_forward_progress_guarantee(
+                      tester<IsSchedulable::Yes, IsNothrowSchedulable::Yes, IsConstSchedulable::No>{})
+                  == execution::forward_progress_guarantee::weakly_parallel);
+    static_assert(execution::get_forward_progress_guarantee(tester<IsSchedulable::Yes, IsNothrowSchedulable::No>{})
+                  == execution::forward_progress_guarantee::weakly_parallel);
+} // namespace forward_progress_guarantee
+
+namespace execute_may_block_caller {
+    enum class IsSchedulable : bool { No, Yes };
+    enum class IsNothrowSchedulable : bool { No, Yes };
+    enum class IsConstSchedulable : bool { No, Yes };
+    enum class DoesReturnsBool : bool { No, Yes };
+
+    template <IsSchedulable Schedulable         = IsSchedulable::Yes,
+        IsNothrowSchedulable NothrowSchedulable = IsNothrowSchedulable::Yes,
+        IsConstSchedulable ConstSchedulable     = IsConstSchedulable::Yes,
+        DoesReturnsBool ReturnsBool             = DoesReturnsBool::Yes>
+    struct tester {
+        friend bool operator==(const tester&, const tester&) noexcept = default;
+        friend constexpr auto tag_invoke(execution::schedule_t, tester) noexcept
+            requires(Schedulable == IsSchedulable::Yes) {
+            return true;
+        }
+
+        friend constexpr auto tag_invoke(this_thread::execute_may_block_caller_t, const tester) noexcept(
+            NothrowSchedulable == IsNothrowSchedulable::Yes) requires(ConstSchedulable == IsConstSchedulable::Yes) {
+            if constexpr (ReturnsBool == DoesReturnsBool::Yes) {
+                return false;
+            } else {
+                return 0;
+            }
+        }
+
+        friend constexpr auto tag_invoke(this_thread::execute_may_block_caller_t, tester&&) noexcept(
+            NothrowSchedulable == IsNothrowSchedulable::Yes) requires(ConstSchedulable != IsConstSchedulable::Yes) {
+            if constexpr (ReturnsBool == DoesReturnsBool::Yes) {
+                return false;
+            } else {
+                return 0;
+            }
+        }
+    };
+
+    static_assert(invocable<this_thread::execute_may_block_caller_t, tester<IsSchedulable::Yes>>);
+    static_assert(!this_thread::execute_may_block_caller(tester<IsSchedulable::Yes>{}));
+
+    // We need to fullfil scheduler
+    static_assert(!invocable<this_thread::execute_may_block_caller_t, tester<IsSchedulable::No>>);
+
+    // Ensure that we fall back to true
+    static_assert(this_thread::execute_may_block_caller(tester<IsSchedulable::Yes, IsNothrowSchedulable::No>{}));
+    static_assert(this_thread::execute_may_block_caller(
+        tester<IsSchedulable::Yes, IsNothrowSchedulable::Yes, IsConstSchedulable::No>{}));
+    static_assert(this_thread::execute_may_block_caller(
+        tester<IsSchedulable::Yes, IsNothrowSchedulable::Yes, IsConstSchedulable::Yes, DoesReturnsBool::No>{}));
+} // namespace execute_may_block_caller
+
+int main() {}
diff --git a/tests/std/tests/P2300R2_executors_sender/env.lst b/tests/std/tests/P2300R2_executors_sender/env.lst
new file mode 100644
index 00000000000..18e2d7c71ec
--- /dev/null
+++ b/tests/std/tests/P2300R2_executors_sender/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\concepts_latest_matrix.lst
diff --git a/tests/std/tests/P2300R2_executors_sender/test.compile.pass.cpp b/tests/std/tests/P2300R2_executors_sender/test.compile.pass.cpp
new file mode 100644
index 00000000000..93772993a09
--- /dev/null
+++ b/tests/std/tests/P2300R2_executors_sender/test.compile.pass.cpp
@@ -0,0 +1,213 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cassert>
+#include <execution>
+using namespace std;
+
+namespace sender {
+    enum class IsMoveConstructible : bool { No, Yes };
+    enum class HasValidTraits { Yes, NoSetValues, NoSetError, NoSetDone };
+    enum class DerivedFromSenderBase : bool { No, Yes };
+
+    template <HasValidTraits ValidTraits>
+    struct traits_base {
+        template <template <class...> class Tuple, template <class...> class Variant>
+        using value_types = Variant<Tuple<int>>;
+
+        template <template <class...> class Variant>
+        using error_types = Variant<>;
+
+        static constexpr bool sends_done = true;
+    };
+
+    template <>
+    struct traits_base<HasValidTraits::NoSetValues> {
+        template <template <class...> class Variant>
+        using error_types = Variant<>;
+
+        static constexpr bool sends_done = true;
+    };
+
+    template <>
+    struct traits_base<HasValidTraits::NoSetError> {
+        template <template <class...> class Tuple, template <class...> class Variant>
+        using value_types = Variant<Tuple<int>>;
+
+        static constexpr bool sends_done = true;
+    };
+
+    template <>
+    struct traits_base<HasValidTraits::NoSetDone> {
+        template <template <class...> class Tuple, template <class...> class Variant>
+        using value_types = Variant<Tuple<int>>;
+
+        template <template <class...> class Variant>
+        using error_types = Variant<>;
+    };
+
+    template <DerivedFromSenderBase FromSenderBase>
+    struct derived_base {};
+
+    template <>
+    struct derived_base<DerivedFromSenderBase::Yes> : public execution::sender_base {};
+
+    template <IsMoveConstructible MoveConstructible = IsMoveConstructible::Yes,
+        HasValidTraits ValidTraits                  = HasValidTraits::Yes,
+        DerivedFromSenderBase FromSenderBase        = DerivedFromSenderBase::Yes>
+    struct sender_tester : traits_base<ValidTraits>, derived_base<FromSenderBase> {
+        sender_tester()                                                                        = default;
+        sender_tester(sender_tester&&) requires(MoveConstructible == IsMoveConstructible::Yes) = default;
+    };
+
+    static_assert(execution::sender<traits_base<HasValidTraits::Yes>>);
+
+    static_assert(execution::sender<sender_tester<IsMoveConstructible::Yes>>);
+    static_assert(!execution::sender<sender_tester<IsMoveConstructible::No>>);
+
+    // Ensure that if we have invalid traits but derived from sender_base we are still good
+    static_assert(execution::sender<sender_tester<IsMoveConstructible::Yes, HasValidTraits::NoSetValues>>);
+    static_assert(execution::sender<sender_tester<IsMoveConstructible::Yes, HasValidTraits::NoSetError>>);
+    static_assert(execution::sender<sender_tester<IsMoveConstructible::Yes, HasValidTraits::NoSetDone>>);
+
+    // If not derived from sender base we are no senders
+    static_assert(!execution::sender<
+                  sender_tester<IsMoveConstructible::Yes, HasValidTraits::NoSetValues, DerivedFromSenderBase::No>>);
+    static_assert(!execution::sender<
+                  sender_tester<IsMoveConstructible::Yes, HasValidTraits::NoSetError, DerivedFromSenderBase::No>>);
+    static_assert(!execution::sender<
+                  sender_tester<IsMoveConstructible::Yes, HasValidTraits::NoSetDone, DerivedFromSenderBase::No>>);
+} // namespace sender
+
+namespace connect {
+    using namespace sender;
+    enum class IsReceiver : bool { No, Yes };
+    enum class HasConnect { Yes, No, NonObservable };
+
+    template <IsReceiver Receiver = IsReceiver::Yes, HasConnect Connect = HasConnect::Yes>
+    struct receiver_tester {
+        struct fake_operation_state {
+            friend constexpr void tag_invoke(execution::start_t, fake_operation_state&) noexcept {}
+        };
+
+        friend constexpr auto tag_invoke(execution::set_done_t, receiver_tester) noexcept
+            requires(Receiver == IsReceiver::Yes) {
+            return true;
+        }
+
+        friend auto tag_invoke(execution::set_error_t, receiver_tester, exception_ptr) noexcept {
+            return true;
+        }
+
+        friend constexpr auto tag_invoke(execution::connect_t, sender_tester<IsMoveConstructible::Yes>,
+            receiver_tester) noexcept requires(Connect == HasConnect::Yes) {
+            return fake_operation_state{};
+        }
+
+        friend constexpr auto tag_invoke(execution::connect_t, sender_tester<IsMoveConstructible::Yes>,
+            receiver_tester) noexcept requires(Connect == HasConnect::NonObservable) {
+            return true;
+        }
+    };
+
+    // Lets connect
+    static_assert(
+        invocable<execution::connect_t, sender_tester<IsMoveConstructible::Yes>, receiver_tester<IsReceiver::Yes>>);
+    static_assert(execution::sender_to<sender_tester<IsMoveConstructible::Yes>, receiver_tester<IsReceiver::Yes>>);
+
+    // Needs sender and receiver
+    static_assert(
+        !invocable<execution::connect_t, sender_tester<IsMoveConstructible::No>, receiver_tester<IsReceiver::Yes>>);
+    static_assert(!execution::sender_to<sender_tester<IsMoveConstructible::No>, receiver_tester<IsReceiver::Yes>>);
+    static_assert(
+        !invocable<execution::connect_t, sender_tester<IsMoveConstructible::Yes>, receiver_tester<IsReceiver::No>>);
+    static_assert(!execution::sender_to<sender_tester<IsMoveConstructible::Yes>, receiver_tester<IsReceiver::No>>);
+
+    // Needs connect method
+    static_assert(!invocable<execution::connect_t, sender_tester<IsMoveConstructible::Yes>,
+                  receiver_tester<IsReceiver::Yes, HasConnect::No>>);
+    static_assert(!execution::sender_to<sender_tester<IsMoveConstructible::Yes>,
+                  receiver_tester<IsReceiver::Yes, HasConnect::No>>);
+
+    // Needs connect that actually returns an observable
+    static_assert(!invocable<execution::connect_t, sender_tester<IsMoveConstructible::Yes>,
+                  receiver_tester<IsReceiver::Yes, HasConnect::NonObservable>>);
+    static_assert(!execution::sender_to<sender_tester<IsMoveConstructible::Yes>,
+                  receiver_tester<IsReceiver::Yes, HasConnect::NonObservable>>);
+} // namespace connect
+
+namespace typed_sender {
+    using namespace sender;
+
+    // We need a sender
+    static_assert(execution::typed_sender<sender_tester<IsMoveConstructible::Yes>>);
+    static_assert(!execution::typed_sender<sender_tester<IsMoveConstructible::No>>);
+
+    // Missing types
+    static_assert(!execution::typed_sender<sender_tester<IsMoveConstructible::Yes, HasValidTraits::NoSetValues>>);
+    static_assert(!execution::typed_sender<sender_tester<IsMoveConstructible::Yes, HasValidTraits::NoSetError>>);
+    static_assert(!execution::typed_sender<sender_tester<IsMoveConstructible::Yes, HasValidTraits::NoSetDone>>);
+} // namespace typed_sender
+
+namespace sender_of {
+    using namespace sender;
+
+    // We need a sender
+    static_assert(execution::sender_of<sender_tester<IsMoveConstructible::Yes>, int>);
+    static_assert(!execution::sender_of<sender_tester<IsMoveConstructible::No>, int>);
+
+    // Missing types
+    static_assert(!execution::sender_of<sender_tester<IsMoveConstructible::Yes, HasValidTraits::NoSetValues>, int>);
+    static_assert(!execution::sender_of<sender_tester<IsMoveConstructible::Yes, HasValidTraits::NoSetError>, int>);
+    static_assert(!execution::sender_of<sender_tester<IsMoveConstructible::Yes, HasValidTraits::NoSetDone>, int>);
+
+    // Wrong type
+    static_assert(!execution::sender_of<sender_tester<IsMoveConstructible::Yes>, double>);
+} // namespace sender_of
+
+namespace get_completion_scheduler {
+    using execution::set_value_t;
+
+    enum class IsSchedulable : bool { No, Yes };
+    enum class IsNothrowInvocable : bool { No, Yes };
+    enum class IsConstInvocable : bool { No, Yes };
+
+    template <IsSchedulable Scheduable>
+    struct fake_scheduler {
+        friend constexpr bool operator==(const fake_scheduler&, const fake_scheduler&) noexcept = default;
+
+        friend constexpr auto tag_invoke(execution::schedule_t, fake_scheduler) noexcept
+            requires(Scheduable == IsSchedulable::Yes) {
+            return true;
+        }
+    };
+
+    template <IsSchedulable Scheduable      = IsSchedulable::Yes,
+        IsNothrowInvocable NothrowInvocable = IsNothrowInvocable::Yes,
+        IsConstInvocable ConstInvocable     = IsConstInvocable::Yes>
+    struct tester : public execution::sender_base {
+        friend constexpr auto tag_invoke(execution::get_completion_scheduler_t<set_value_t>, const tester&) noexcept(
+            NothrowInvocable == IsNothrowInvocable::Yes) requires(ConstInvocable == IsConstInvocable::Yes) {
+            return fake_scheduler<Scheduable>{};
+        }
+
+        friend constexpr auto tag_invoke(execution::get_completion_scheduler_t<set_value_t>, tester&&) noexcept {
+            return fake_scheduler<Scheduable>{};
+        }
+    };
+
+    static_assert(invocable<execution::get_completion_scheduler_t<execution::set_value_t>, tester<IsSchedulable::Yes>>);
+    static_assert(execution::get_completion_scheduler<execution::set_value_t>(tester<IsSchedulable::Yes>{})
+                  == fake_scheduler<IsSchedulable::Yes>{});
+
+    // We need to fullfil scheduler
+    static_assert(!invocable<execution::get_completion_scheduler_t<execution::set_value_t>, tester<IsSchedulable::No>>);
+
+    // Ensure that we fulfill observable
+    static_assert(!invocable<execution::get_completion_scheduler_t<execution::set_value_t>,
+                  tester<IsSchedulable::Yes, IsNothrowInvocable::No>>);
+    static_assert(!invocable<execution::get_completion_scheduler_t<execution::set_value_t>,
+                  tester<IsSchedulable::Yes, IsNothrowInvocable::Yes, IsConstInvocable::No>>);
+} // namespace get_completion_scheduler
+
+int main() {}
diff --git a/tests/std/tests/P2300R2_executors_tag_invoke/env.lst b/tests/std/tests/P2300R2_executors_tag_invoke/env.lst
new file mode 100644
index 00000000000..18e2d7c71ec
--- /dev/null
+++ b/tests/std/tests/P2300R2_executors_tag_invoke/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\concepts_latest_matrix.lst
diff --git a/tests/std/tests/P2300R2_executors_tag_invoke/test.compile.pass.cpp b/tests/std/tests/P2300R2_executors_tag_invoke/test.compile.pass.cpp
new file mode 100644
index 00000000000..e58e0599cf2
--- /dev/null
+++ b/tests/std/tests/P2300R2_executors_tag_invoke/test.compile.pass.cpp
@@ -0,0 +1,206 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cassert>
+#include <functional>
+using namespace std;
+
+struct whatever {};
+struct with_const {};
+struct with_reference {};
+struct conversion_target {};
+struct with_conversion {
+    operator conversion_target() noexcept {
+        return {};
+    }
+};
+struct with_explicit_conversion {
+    explicit operator conversion_target() noexcept {
+        return {};
+    }
+};
+
+struct noexcept_function {};
+struct noexcept_observable {};
+
+namespace meow {
+    struct meow_tag_t {};
+    struct meow_other_tag_t {};
+
+    auto tag_invoke(meow_tag_t, int) -> int;
+    auto tag_invoke(meow_tag_t, double) -> double;
+    auto tag_invoke(meow_tag_t, whatever, int) -> whatever;
+    auto tag_invoke(meow_tag_t, const with_const) -> const with_const;
+    auto tag_invoke(meow_tag_t, with_reference&) -> with_reference&;
+    auto tag_invoke(meow_tag_t, conversion_target) -> conversion_target;
+    auto tag_invoke(meow_tag_t, noexcept_function&&) noexcept -> noexcept_function;
+    auto tag_invoke(meow_tag_t, const noexcept_observable) noexcept -> noexcept_observable;
+
+    namespace woof {
+        auto tag_invoke(meow_other_tag_t, long) -> int;
+    }
+} // namespace meow
+
+namespace bark {
+    struct with_conversion_other_namespace {
+        operator conversion_target() noexcept {
+            return {};
+        }
+    };
+
+    auto tag_invoke(meow::meow_other_tag_t, double) -> int;
+} // namespace bark
+
+namespace non_associated {
+    struct meow {
+        template <_Non_associated T>
+        void operator()(T) {}
+    };
+
+    static_assert(!is_invocable_v<meow, int>);
+    static_assert(is_invocable_v<meow, _Unassociate<int>>);
+    static_assert(same_as<int, _Reassociate<_Unassociate<int>>>);
+
+    constexpr void test_associated(auto);
+} // namespace non_associated
+
+template <typename, class = void>
+constexpr bool is_associated = false;
+template <typename T>
+constexpr bool is_associated<T, void_t<decltype(test_associated(declval<T>()))>> = true;
+
+static_assert(is_associated<non_associated::meow>);
+static_assert(!is_associated<_Unassociate<non_associated::meow>>);
+
+namespace callable {
+    // Functions
+    static_assert(_Callable<void()>);
+    static_assert(!_Callable<void(), int>);
+    static_assert(_Callable<void(int), int>);
+    static_assert(_Callable<void(int), char>);
+    static_assert(_Callable<void(int), short>);
+    static_assert(_Callable<void(int), long>);
+    static_assert(_Callable<void(conversion_target), with_conversion>);
+    static_assert(!_Callable<void(conversion_target), with_explicit_conversion>);
+
+    // Function pointers
+    static_assert(_Callable<void (*)()>);
+    static_assert(!_Callable<void (*)(), int>);
+    static_assert(_Callable<void (*)(int), int>);
+    static_assert(_Callable<void (*)(int), char>);
+    static_assert(_Callable<void (*)(int), short>);
+    static_assert(_Callable<void (*)(int), long>);
+    static_assert(_Callable<void (*)(conversion_target), with_conversion>);
+    static_assert(!_Callable<void (*)(conversion_target), with_explicit_conversion>);
+
+    // Functors
+    static_assert(_Callable<decltype([]() {})>);
+    static_assert(!_Callable<decltype([]() {}), int>);
+    static_assert(_Callable<decltype([](int) {}), int>);
+    static_assert(_Callable<decltype([](int) {}), char>);
+    static_assert(_Callable<decltype([](int) {}), short>);
+    static_assert(_Callable<decltype([](int) {}), long>);
+    static_assert(_Callable<decltype([](int) {}), long>);
+    static_assert(_Callable<decltype([](conversion_target) {}), with_conversion>);
+    static_assert(!_Callable<decltype([](conversion_target) {}), with_explicit_conversion>);
+
+    // Check nothrow
+    static_assert(!_Nothrow_callable<void (*)()>);
+    static_assert(!_Nothrow_callable<void (*)(), int>);
+    static_assert(!_Nothrow_callable<void (*)(int), int>);
+    static_assert(!_Nothrow_callable<void (*)(int), char>);
+    static_assert(!_Nothrow_callable<void (*)(int), short>);
+    static_assert(!_Nothrow_callable<void (*)(int), long>);
+    static_assert(!_Nothrow_callable<void (*)(conversion_target), with_conversion>);
+    static_assert(!_Nothrow_callable<void (*)(conversion_target), with_explicit_conversion>);
+
+    static_assert(_Nothrow_callable<decltype([]() noexcept {})>);
+    static_assert(!_Nothrow_callable<decltype([]() noexcept {}), int>);
+    static_assert(_Nothrow_callable<decltype([](int) noexcept {}), int>);
+    static_assert(_Nothrow_callable<decltype([](int) noexcept {}), char>);
+    static_assert(_Nothrow_callable<decltype([](int) noexcept {}), short>);
+    static_assert(_Nothrow_callable<decltype([](int) noexcept {}), long>);
+    static_assert(_Nothrow_callable<decltype([](int) noexcept {}), long>);
+    static_assert(_Nothrow_callable<decltype([](conversion_target) noexcept {}), with_conversion>);
+    static_assert(!_Nothrow_callable<decltype([](conversion_target) noexcept {}), with_explicit_conversion>);
+} // namespace callable
+
+// Matching declarations
+static_assert(tag_invocable<meow::meow_tag_t, int>);
+static_assert(tag_invocable<meow::meow_tag_t, double>);
+static_assert(tag_invocable<meow::meow_tag_t, whatever, int>);
+static_assert(tag_invocable<meow::meow_tag_t, conversion_target>);
+
+// Wrong number of arguments
+static_assert(!tag_invocable<meow::meow_tag_t, int, int>);
+static_assert(!tag_invocable<meow::meow_tag_t, double, int>);
+static_assert(!tag_invocable<meow::meow_tag_t, whatever, int, int>);
+static_assert(!tag_invocable<meow::meow_tag_t>);
+
+// With Conversions
+static_assert(tag_invocable<meow::meow_tag_t, with_conversion>);
+static_assert(tag_invocable<meow::meow_tag_t, bark::with_conversion_other_namespace>);
+static_assert(!tag_invocable<meow::meow_tag_t, with_explicit_conversion>);
+
+// With Qualifiers
+static_assert(tag_invocable<meow::meow_tag_t, const int>);
+static_assert(tag_invocable<meow::meow_tag_t, volatile int>);
+static_assert(tag_invocable<meow::meow_tag_t, const volatile int>);
+
+// Need to bind to reference
+// static_assert(!tag_invocable<meow::meow_tag_t, with_reference>); // TODO MSVC permissive BUG
+static_assert(tag_invocable<meow::meow_tag_t, with_reference&>);
+// static_assert(!tag_invocable<meow::meow_tag_t, with_reference&&>); // TODO MSVC permissive BUG
+static_assert(!tag_invocable<meow::meow_tag_t, const with_reference>);
+static_assert(!tag_invocable<meow::meow_tag_t, const with_reference&>);
+static_assert(!tag_invocable<meow::meow_tag_t, const with_reference&&>);
+
+// Need to bind qualifier
+static_assert(tag_invocable<meow::meow_tag_t, with_const>);
+static_assert(tag_invocable<meow::meow_tag_t, const with_const>);
+static_assert(!tag_invocable<meow::meow_tag_t, volatile with_const>);
+static_assert(!tag_invocable<meow::meow_tag_t, const volatile with_const>);
+
+static_assert(tag_invocable<meow::meow_tag_t, with_const&>);
+static_assert(tag_invocable<meow::meow_tag_t, const with_const&>);
+static_assert(!tag_invocable<meow::meow_tag_t, volatile with_const&>);
+static_assert(!tag_invocable<meow::meow_tag_t, const volatile with_const&>);
+
+static_assert(tag_invocable<meow::meow_tag_t, with_const&&>);
+static_assert(tag_invocable<meow::meow_tag_t, const with_const&&>);
+static_assert(!tag_invocable<meow::meow_tag_t, volatile with_const&&>);
+static_assert(!tag_invocable<meow::meow_tag_t, const volatile with_const&&>);
+
+// References can bind to values
+static_assert(tag_invocable<meow::meow_tag_t, int&>);
+static_assert(tag_invocable<meow::meow_tag_t, int&&>);
+static_assert(tag_invocable<meow::meow_tag_t, const int&>);
+static_assert(tag_invocable<meow::meow_tag_t, const int&&>);
+
+// Matching tag only
+static_assert(!tag_invocable<meow::meow_other_tag_t, int>);
+
+// Only in associated namespaces
+static_assert(!tag_invocable<meow::meow_other_tag_t, double>);
+static_assert(!tag_invocable<meow::meow_other_tag_t, long>);
+
+// noexcept is properly handled
+static_assert(!nothrow_tag_invocable<meow::meow_tag_t, int>);
+static_assert(nothrow_tag_invocable<meow::meow_tag_t, noexcept_function>);
+
+// tag_observable requires const arguments
+static_assert(!tag_observable<meow::meow_tag_t, int>);
+static_assert(!tag_observable<meow::meow_tag_t, noexcept_function>);
+static_assert(tag_observable<meow::meow_tag_t, noexcept_observable>);
+
+// result type is properly determined
+static_assert(is_same_v<tag_invoke_result_t<meow::meow_tag_t, int>, int>);
+static_assert(is_same_v<tag_invoke_result_t<meow::meow_tag_t, double>, double>);
+static_assert(is_same_v<tag_invoke_result_t<meow::meow_tag_t, float>, double>);
+static_assert(is_same_v<tag_invoke_result_t<meow::meow_tag_t, short>, int>);
+static_assert(is_same_v<tag_invoke_result_t<meow::meow_tag_t, conversion_target>, conversion_target>);
+static_assert(is_same_v<tag_invoke_result_t<meow::meow_tag_t, with_conversion>, conversion_target>);
+static_assert(is_same_v<tag_invoke_result_t<meow::meow_tag_t, with_const>, const with_const>);
+static_assert(is_same_v<tag_invoke_result_t<meow::meow_tag_t, with_reference&>, with_reference&>);
+
+int main() {}
diff --git a/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp b/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
index 83f3c86bf29..e5854220914 100644
--- a/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
+++ b/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
@@ -714,6 +714,20 @@ STATIC_ASSERT(__cpp_lib_execution == 201603L);
 #endif
 #endif
 
+#if _HAS_CXX23 && !defined(__EDG__) // TRANSITION, EDG concepts support
+#ifndef __cpp_lib_executors
+#error __cpp_lib_executors is not defined
+#elif __cpp_lib_executors != 202306L
+#error __cpp_lib_executors is not 202306L
+#else
+STATIC_ASSERT(__cpp_lib_executors == 202306L);
+#endif
+#else
+#ifdef __cpp_lib_executors
+#error __cpp_lib_executors is defined
+#endif
+#endif
+
 #if _HAS_CXX23 && !defined(__EDG__) // TRANSITION, EDG concepts support
 #ifndef __cpp_lib_expected
 #error __cpp_lib_expected is not defined