diff --git a/include/exec/detail/numa.hpp b/include/exec/detail/numa.hpp
index 26b42f5ac..d1edf64fd 100644
--- a/include/exec/detail/numa.hpp
+++ b/include/exec/detail/numa.hpp
@@ -16,232 +16,64 @@
  */
 #pragma once
 
+#include "../../stdexec/__detail/__any.hpp"
 #include "../../stdexec/__detail/__config.hpp"
 #include "../scope.hpp"  // IWYU pragma: keep
 
-#include <algorithm>  // IWYU pragma: keep
 #include <cstddef>
-#include <memory>
-#include <new>  // IWYU pragma: keep
 #include <thread>
-#include <utility>
-#include <vector>
-
-// Work around a bug in the NVHPC compilers prior to version 24.3
-#if STDEXEC_NVHPC() && STDEXEC_NVHPC_VERSION < 24'03
-#  define STDEXEC_NUMA_VTABLE_INLINE
-#else
-#  define STDEXEC_NUMA_VTABLE_INLINE inline
-#endif
+#include <vector>  // IWYU pragma: keep
 
 namespace experimental::execution
 {
   namespace _numa
   {
-    using _small_t = void *[1];
-
-    template <class T>
-    using _is_small = STDEXEC::__mbool<sizeof(T) <= sizeof(_small_t)>;
-
-    union _storage
-    {
-      _storage() noexcept = default;
-
-      template <STDEXEC::__not_decays_to<_storage> Ty>
-      explicit _storage(Ty &&value)
-        : ptr{new STDEXEC::__decay_t<Ty>{static_cast<Ty &&>(value)}}
-      {}
-
-      template <STDEXEC::__not_decays_to<_storage> Ty>
-        requires(_is_small<STDEXEC::__decay_t<Ty>>::value)
-      explicit _storage(Ty &&value) noexcept(STDEXEC::__nothrow_decay_copyable<Ty>)
-        : buf{}
+    // NOLINTBEGIN(modernize-use-override)
+    template <class Base>
+    struct _ipolicy
+      : STDEXEC::__any::__interface_base<_ipolicy,
+                                         Base,
+                                         STDEXEC::__any::__extends<STDEXEC::__any::__icopyable>,
+                                         sizeof(void *)>
+    {
+      using _ipolicy::__interface_base::__interface_base;
+
+      [[nodiscard]]
+      constexpr virtual auto num_nodes() const noexcept -> std::size_t
       {
-        ::new (static_cast<void *>(buf)) STDEXEC::__decay_t<Ty>{static_cast<Ty &&>(value)};
+        return STDEXEC::__any::__value(*this).num_nodes();
       }
 
-      void *ptr{};
-      char  buf[sizeof(_small_t)];
-    };
-
-    struct _vtable
-    {
-      auto (*move)(_storage *, _storage *) noexcept -> void;
-      auto (*copy)(_storage *, _storage const *) -> void;
-      auto (*destroy)(_storage *) noexcept -> void;
-      auto (*num_nodes)(_storage const *) noexcept -> std::size_t;
-      auto (*num_cpus)(_storage const *, int) noexcept -> std::size_t;
-      auto (*bind_to_node)(_storage const *, int) noexcept -> int;
-      auto (*thread_index_to_node)(_storage const *, std::size_t) noexcept -> int;
-    };
-
-    template <class T>
-    struct _vtable_for
-    {
-      // move
-      static auto _move(_storage *self, _storage *other) noexcept -> void
+      [[nodiscard]]
+      constexpr virtual auto num_cpus(int node) const noexcept -> std::size_t
       {
-        if constexpr (!_is_small<T>::value)
-        {
-          self->ptr = std::exchange(other->ptr, nullptr);
-        }
-        else
-        {
-          ::new (static_cast<void *>(self->buf))
-            T{static_cast<T &&>(*reinterpret_cast<T *>(other->buf))};
-        }
+        return STDEXEC::__any::__value(*this).num_cpus(node);
       }
 
-      // copy
-      static auto _copy(_storage *self, _storage const *other) noexcept -> void
+      // NOLINTNEXTLINE(modernize-use-nodiscard)
+      constexpr virtual auto bind_to_node(int node) const noexcept -> int
       {
-        if constexpr (!_is_small<T>::value)
-        {
-          self->ptr = new T{*static_cast<T const *>(other->ptr)};
-        }
-        else
-        {
-          ::new (static_cast<void *>(self->buf)) T{*reinterpret_cast<T const *>(other->buf)};
-        }
+        return STDEXEC::__any::__value(*this).bind_to_node(node);
       }
 
-      // destroy
-      static auto _destroy(_storage *self) noexcept -> void
+      [[nodiscard]]
+      constexpr virtual auto thread_index_to_node(std::size_t index) const noexcept -> int
       {
-        if constexpr (!_is_small<T>::value)
-        {
-          delete static_cast<T *>(self->ptr);
-        }
-        else
-        {
-          std::destroy_at(reinterpret_cast<T *>(self->buf));
-        }
-      }
-
-      // num_nodes
-      static auto _num_nodes(_storage const *self) noexcept -> std::size_t
-      {
-        if constexpr (!_is_small<T>::value)
-        {
-          return static_cast<T const *>(self->ptr)->num_nodes();
-        }
-        else
-        {
-          return reinterpret_cast<T const *>(self->buf)->num_nodes();
-        }
-      }
-
-      // num_cpus
-      static auto _num_cpus(_storage const *self, int node) noexcept -> std::size_t
-      {
-        if constexpr (!_is_small<T>::value)
-        {
-          return static_cast<T const *>(self->ptr)->num_cpus(node);
-        }
-        else
-        {
-          return reinterpret_cast<T const *>(self->buf)->num_cpus(node);
-        }
-      }
-
-      // bind_to_node
-      static auto _bind_to_node(_storage const *self, int node) noexcept -> int
-      {
-        if constexpr (!_is_small<T>::value)
-        {
-          return static_cast<T const *>(self->ptr)->bind_to_node(node);
-        }
-        else
-        {
-          return reinterpret_cast<T const *>(self->buf)->bind_to_node(node);
-        }
-      }
-
-      // thread_index_to_node
-      static auto _thread_index_to_node(_storage const *self, std::size_t index) noexcept -> int
-      {
-        if constexpr (!_is_small<T>::value)
-        {
-          return static_cast<T const *>(self->ptr)->thread_index_to_node(index);
-        }
-        else
-        {
-          return reinterpret_cast<T const *>(self->buf)->thread_index_to_node(index);
-        }
+        return STDEXEC::__any::__value(*this).thread_index_to_node(index);
       }
     };
-
-    template <class NumaPolicy>
-    STDEXEC_NUMA_VTABLE_INLINE constexpr _vtable _vtable_for_v = {
-      .move                 = _vtable_for<NumaPolicy>::_move,
-      .copy                 = _vtable_for<NumaPolicy>::_copy,
-      .destroy              = _vtable_for<NumaPolicy>::_destroy,
-      .num_nodes            = _vtable_for<NumaPolicy>::_num_nodes,
-      .num_cpus             = _vtable_for<NumaPolicy>::_num_cpus,
-      .bind_to_node         = _vtable_for<NumaPolicy>::_bind_to_node,
-      .thread_index_to_node = _vtable_for<NumaPolicy>::_thread_index_to_node};
+    // NOLINTEND(modernize-use-override)
   }  // namespace _numa
 
-  struct numa_policy
+  struct numa_policy final : STDEXEC::__any::__any<exec::_numa::_ipolicy>
   {
-   private:
-    _numa::_vtable const *vtable_;
-    _numa::_storage       storage_;
-
-   public:
-    template <STDEXEC::__not_decays_to<numa_policy> NumaPolicy>
-    numa_policy(NumaPolicy &&policy)
-      : vtable_(&_numa::_vtable_for_v<STDEXEC::__decay_t<NumaPolicy>>)
-      , storage_(static_cast<NumaPolicy &&>(policy))
-    {}
-
-    numa_policy(numa_policy &&other) noexcept
-      : vtable_(other.vtable_)
-      , storage_{}
-    {
-      vtable_->move(&storage_, &other.storage_);
-    }
-
-    numa_policy(numa_policy const &other)
-      : vtable_(other.vtable_)
-      , storage_{}
-    {
-      vtable_->copy(&storage_, &other.storage_);
-    }
-
-    ~numa_policy()
-    {
-      vtable_->destroy(&storage_);
-    }
-
-    [[nodiscard]]
-    auto num_nodes() const noexcept -> std::size_t
-    {
-      return vtable_->num_nodes(&storage_);
-    }
-
-    [[nodiscard]]
-    auto num_cpus(int node) const noexcept -> std::size_t
-    {
-      return vtable_->num_cpus(&storage_, node);
-    }
-
-    auto bind_to_node(int node) const noexcept -> int
-    {  // NOLINT(modernize-use-nodiscard)
-      return vtable_->bind_to_node(&storage_, node);
-    }
-
-    [[nodiscard]]
-    auto thread_index_to_node(std::size_t index) const noexcept -> int
-    {
-      return vtable_->thread_index_to_node(&storage_, index);
-    }
+    using numa_policy::__any::__any;
   };
 
   struct no_numa_policy
   {
     [[nodiscard]]
-    auto num_nodes() const noexcept -> std::size_t
+    constexpr auto num_nodes() const noexcept -> std::size_t
     {
       return 1;
     }
@@ -252,13 +84,13 @@ namespace experimental::execution
       return std::thread::hardware_concurrency();
     }
 
-    auto bind_to_node(int) const noexcept -> int
-    {  // NOLINT(modernize-use-nodiscard)
+    constexpr auto bind_to_node(int) const noexcept -> int  // NOLINT(modernize-use-nodiscard)
+    {
       return 0;
     }
 
     [[nodiscard]]
-    auto thread_index_to_node(std::size_t) const noexcept -> int
+    constexpr auto thread_index_to_node(std::size_t) const noexcept -> int
     {
       return 0;
     }
@@ -312,17 +144,19 @@ namespace experimental::execution
 
   struct default_numa_policy
   {
+    [[nodiscard]]
     std::size_t num_nodes() const noexcept
     {
       return _node_to_thread_index::get().size();
     }
 
+    [[nodiscard]]
     std::size_t num_cpus(int node) const noexcept
     {
       return exec::_get_numa_num_cpus(node);
     }
 
-    int bind_to_node(int node) const noexcept
+    int bind_to_node(int node) const noexcept  // NOLINT(modernize-use-nodiscard)
     {
       struct ::bitmask *nodes = ::numa_allocate_nodemask();
       if (!nodes)
@@ -335,6 +169,7 @@ namespace experimental::execution
       return 0;
     }
 
+    [[nodiscard]]
     int thread_index_to_node(std::size_t idx) const noexcept
     {
       auto const &node_to_thread_index = _node_to_thread_index::get();
@@ -370,8 +205,6 @@ namespace experimental::execution
       : node_(other.node_)
     {}
 
-    int node_;
-
     void *do_allocate(std::size_t n)
     {
       return ::numa_alloc_onnode(n, node_);
@@ -393,6 +226,12 @@ namespace experimental::execution
     }
 
     friend bool operator==(numa_allocator const &, numa_allocator const &) noexcept = default;
+
+   private:
+    template <class>
+    friend struct numa_allocator;
+
+    int node_;
   };
 
   class nodemask
@@ -406,7 +245,6 @@ namespace experimental::execution
 
    public:
     nodemask() noexcept
-      : mask_{}
     {
       ::copy_bitmask_to_nodemask(::numa_no_nodes_ptr, &mask_);
     }
@@ -453,13 +291,14 @@ namespace experimental::execution
     }
 
    private:
-    ::nodemask_t mask_;
+    ::nodemask_t mask_{};
   };
 }  // namespace experimental::execution
 
 namespace exec = experimental::execution;
 
 #else
+
 namespace experimental::execution
 {
   using default_numa_policy = no_numa_policy;
@@ -470,32 +309,13 @@ namespace experimental::execution
   }
 
   template <class T>
-  struct numa_allocator
+  struct numa_allocator : std::allocator<T>
   {
-    using pointer       = T *;
-    using const_pointer = T const *;
-    using value_type    = T;
+    constexpr numa_allocator(int) noexcept {}
 
-    explicit numa_allocator(int) noexcept {}
-
-    template <class U>
-    explicit numa_allocator(numa_allocator<U> const &) noexcept
+    template <STDEXEC::__not_same_as<T> U>
+    numa_allocator(numa_allocator<U> const &) noexcept
     {}
-
-    auto allocate(std::size_t n) -> T *
-    {
-      std::allocator<T> alloc{};
-      return alloc.allocate(n);
-    }
-
-    void deallocate(T *p, std::size_t n)
-    {
-      std::allocator<T> alloc{};
-      alloc.deallocate(p, n);
-    }
-
-    friend auto
-    operator==(numa_allocator const &, numa_allocator const &) noexcept -> bool = default;
   };
 
   class nodemask
@@ -538,4 +358,4 @@ namespace experimental::execution
 
 namespace exec = experimental::execution;
 
-#endif
\ No newline at end of file
+#endif
diff --git a/include/stdexec/__detail/__any.hpp b/include/stdexec/__detail/__any.hpp
index 0ffe8f3ae..3598458ba 100644
--- a/include/stdexec/__detail/__any.hpp
+++ b/include/stdexec/__detail/__any.hpp
@@ -35,6 +35,8 @@
 STDEXEC_PRAGMA_PUSH()
 STDEXEC_PRAGMA_IGNORE_GNU("-Wredundant-consteval-if")
 
+// NOLINTBEGIN(moderize-use-override)
+
 namespace STDEXEC::__any
 {
 
@@ -182,7 +184,7 @@ namespace STDEXEC::__any
             class _BaseInterfaces   = __extends<>,
             size_t _BufferSize      = __default_buffer_size,
             size_t _BufferAlignment = alignof(std::max_align_t)>
-  struct interface;
+  struct __interface_base;
 
   //////////////////////////////////////////////////////////////////////////////////////////
   // __interface_cast
@@ -394,7 +396,7 @@ namespace STDEXEC::__any
 
    private:
     template <template <class> class, class, class, size_t, size_t>
-    friend struct interface;
+    friend struct __interface_base;
     friend struct __access;
 
     template <class _Self>
@@ -631,13 +633,13 @@ namespace STDEXEC::__any
   {};
 
   //////////////////////////////////////////////////////////////////////////////////////////
-  //! interface
+  //! __interface_base
   template <template <class> class _Interface,
             class _Base,
             class _BaseInterfaces,
             size_t _BufferSize,
             size_t _BufferAlignment>
-  struct interface : _Base
+  struct __interface_base : _Base
   {
     static_assert(std::popcount(_BufferAlignment) == 1, "BufferAlignment must be a power of two");
     using __bases_type          = _BaseInterfaces;
@@ -646,8 +648,10 @@ namespace STDEXEC::__any
     using _Base::__slice_to_;
     using _Base::_Base;
 
-    static constexpr size_t __buffer_size = _BufferSize > _Base::__buffer_size
-                                            ? _BufferSize
+    // The actual buffer size is the user-specified buffer size plus the size of a pointer,
+    // because space is needed for the virtual table pointer.
+    static constexpr size_t __buffer_size = _BufferSize + sizeof(void *) > _Base::__buffer_size
+                                            ? _BufferSize + sizeof(void *)
                                             : _Base::__buffer_size;
 
     static constexpr size_t __buffer_alignment = _BufferAlignment > _Base::__buffer_alignment
@@ -1568,9 +1572,9 @@ namespace STDEXEC::__any
   //////////////////////////////////////////////////////////////////////////////////////////
   // __imovable
   template <class _Base>
-  struct __imovable : interface<__imovable, _Base>
+  struct __imovable : __interface_base<__imovable, _Base>
   {
-    using __imovable::interface::interface;
+    using __imovable::__interface_base::__interface_base;
 
     constexpr virtual void __move_to(__iroot *&, std::span<std::byte>) noexcept
     {
@@ -1581,9 +1585,9 @@ namespace STDEXEC::__any
   //////////////////////////////////////////////////////////////////////////////////////////
   // __icopyable
   template <class _Base>
-  struct __icopyable : interface<__icopyable, _Base, __extends<__imovable>>
+  struct __icopyable : __interface_base<__icopyable, _Base, __extends<__imovable>>
   {
-    using __icopyable::interface::interface;
+    using __icopyable::__interface_base::__interface_base;
 
     constexpr virtual void __copy_to(__iroot *&, std::span<std::byte>) const
     {
@@ -1599,7 +1603,7 @@ namespace STDEXEC::__any
   //////////////////////////////////////////////////////////////////////////////////////////
   // any
   template <template <class> class _Interface>
-  struct __any final : __value_proxy_model<_Interface>
+  struct __any : __value_proxy_model<_Interface>
   {
    private:
     template <class _Other>
@@ -1975,9 +1979,9 @@ namespace STDEXEC::__any
   //////////////////////////////////////////////////////////////////////////////////////////
   // __iequality_comparable
   template <class _Base>
-  struct __iequality_comparable : interface<__iequality_comparable, _Base>
+  struct __iequality_comparable : __interface_base<__iequality_comparable, _Base>
   {
-    using __iequality_comparable::interface::interface;
+    using __iequality_comparable::__interface_base::__interface_base;
 
     template <class _Other>
     [[nodiscard]]
@@ -2008,11 +2012,13 @@ namespace STDEXEC::__any
   // __isemiregular
   template <class _Base>
   struct __isemiregular
-    : interface<__isemiregular, _Base, __extends<__icopyable, __iequality_comparable>>
+    : __interface_base<__isemiregular, _Base, __extends<__icopyable, __iequality_comparable>>
   {
-    using __isemiregular::interface::interface;
+    using __isemiregular::__interface_base::__interface_base;
   };
 
 }  // namespace STDEXEC::__any
 
+// NOLINTEND(moderize-use-override)
+
 STDEXEC_PRAGMA_POP()
diff --git a/include/stdexec/__detail/__any_allocator.hpp b/include/stdexec/__detail/__any_allocator.hpp
index 0997f9e05..0e7e15871 100644
--- a/include/stdexec/__detail/__any_allocator.hpp
+++ b/include/stdexec/__detail/__any_allocator.hpp
@@ -32,15 +32,15 @@ namespace STDEXEC
 
     template <class _Base>
     using __byte_allocator_interface_t =
-      __any::interface<__byte_allocator,
-                       _Base,
-                       __any::__extends<__any::__icopyable, __any::__iequality_comparable>>;
+      __any::__interface_base<__byte_allocator,
+                              _Base,
+                              __any::__extends<__any::__icopyable, __any::__iequality_comparable>>;
 
     // NOLINTBEGIN(modernize-use-override)
     template <class _Base>
     struct __byte_allocator : __byte_allocator_interface_t<_Base>
     {
-      using __byte_allocator_interface_t<_Base>::interface::interface;
+      using __byte_allocator_interface_t<_Base>::__interface_base::__interface_base;
 
       [[nodiscard]]
       constexpr virtual auto allocate(size_t __n) -> std::byte*
@@ -107,7 +107,10 @@ namespace STDEXEC
     constexpr auto operator==(__any_allocator const &) const noexcept -> bool = default;
 
    private:
-    __any::__any<__detail::__byte_allocator> __alloc_{};
+    struct __alloc_impl final : __any::__any<__detail::__byte_allocator>
+    {
+      using __alloc_impl::__any::__any;
+    } __alloc_{};
   };
 
   template <class _Alloc>
diff --git a/test/stdexec/detail/test_any.cpp b/test/stdexec/detail/test_any.cpp
index 2cb05dd31..c1e822efc 100644
--- a/test/stdexec/detail/test_any.cpp
+++ b/test/stdexec/detail/test_any.cpp
@@ -23,9 +23,9 @@
 namespace any = STDEXEC::__any;
 
 template <class Base>
-struct ifoo : any::interface<ifoo, Base>
+struct ifoo : any::__interface_base<ifoo, Base>
 {
-  using ifoo::interface::interface;
+  using ifoo::__interface_base::__interface_base;
 
   constexpr virtual void foo()
   {
@@ -39,9 +39,9 @@ struct ifoo : any::interface<ifoo, Base>
 };
 
 template <class Base>
-struct ibar : any::interface<ibar, Base, any::__extends<ifoo, any::__icopyable>>
+struct ibar : any::__interface_base<ibar, Base, any::__extends<ifoo, any::__icopyable>>
 {
-  using ibar::interface::interface;
+  using ibar::__interface_base::__interface_base;
 
   constexpr virtual void bar()
   {
@@ -50,9 +50,9 @@ struct ibar : any::interface<ibar, Base, any::__extends<ifoo, any::__icopyable>>
 };
 
 template <class Base>
-struct ibaz : any::interface<ibaz, Base, any::__extends<ibar>, 5 * sizeof(void *)>
+struct ibaz : any::__interface_base<ibaz, Base, any::__extends<ibar>, 5 * sizeof(void *)>
 {
-  using ibaz::interface::interface;
+  using ibaz::__interface_base::__interface_base;
 
   constexpr ~ibaz() = default;
 
@@ -114,9 +114,9 @@ static_assert(any::__extension_of<any::__iabstract<ibar>, any::__icopyable>);
 
 // Test the Diamond of Death inheritance problem:
 template <class Base>
-struct IFoo : any::interface<IFoo, Base, any::__extends<any::__icopyable>>
+struct IFoo : any::__interface_base<IFoo, Base, any::__extends<any::__icopyable>>
 {
-  using IFoo::interface::interface;
+  using IFoo::__interface_base::__interface_base;
 
   constexpr virtual void foo()
   {
@@ -125,9 +125,9 @@ struct IFoo : any::interface<IFoo, Base, any::__extends<any::__icopyable>>
 };
 
 template <class Base>
-struct IBar : any::interface<IBar, Base, any::__extends<any::__icopyable>>
+struct IBar : any::__interface_base<IBar, Base, any::__extends<any::__icopyable>>
 {
-  using IBar::interface::interface;
+  using IBar::__interface_base::__interface_base;
 
   constexpr virtual void bar()
   {
@@ -136,10 +136,10 @@ struct IBar : any::interface<IBar, Base, any::__extends<any::__icopyable>>
 };
 
 template <class Base>
-struct IBaz : any::interface<IBaz, Base, any::__extends<IFoo, IBar>>  // inherits twice
-                                                                      // from __icopyable
+struct IBaz : any::__interface_base<IBaz, Base, any::__extends<IFoo, IBar>>  // inherits twice
+                                                                             // from __icopyable
 {
-  using IBaz::interface::interface;
+  using IBaz::__interface_base::__interface_base;
 
   constexpr virtual void baz()
   {