diff --git a/include/boost/math/differentiation/autodiff_reverse.hpp b/include/boost/math/differentiation/autodiff_reverse.hpp
index d6948705d..dc7b43521 100644
--- a/include/boost/math/differentiation/autodiff_reverse.hpp
+++ b/include/boost/math/differentiation/autodiff_reverse.hpp
@@ -6,12 +6,23 @@
 #define BOOST_MATH_DIFFERENTIATION_AUTODIFF_HPP
 
 #include <boost/math/constants/constants.hpp>
-#include <boost/math/differentiation/detail/reverse_mode_autodiff_basic_operator_overloads.hpp>
+
+#ifndef BOOST_MATH_ET_OFF
+#define BOOST_MATH_ET_ON
+#endif
+
+#ifdef BOOST_MATH_ET_ON
+#include <boost/math/differentiation/detail/reverse_mode_autodiff_basic_ops_et.hpp>
+#include <boost/math/differentiation/detail/reverse_mode_autodiff_stl_et.hpp>
+#else
+#include <boost/math/differentiation/detail/reverse_mode_autodiff_basic_ops_no_et.hpp>
+#include <boost/math/differentiation/detail/reverse_mode_autodiff_stl_no_et.hpp>
+#endif
+
 #include <boost/math/differentiation/detail/reverse_mode_autodiff_comparison_operator_overloads.hpp>
 #include <boost/math/differentiation/detail/reverse_mode_autodiff_erf_overloads.hpp>
 #include <boost/math/differentiation/detail/reverse_mode_autodiff_expression_template_base.hpp>
 #include <boost/math/differentiation/detail/reverse_mode_autodiff_memory_management.hpp>
-#include <boost/math/differentiation/detail/reverse_mode_autodiff_stl_overloads.hpp>
 #include <boost/math/special_functions/acosh.hpp>
 #include <boost/math/special_functions/asinh.hpp>
 #include <boost/math/special_functions/atanh.hpp>
diff --git a/include/boost/math/differentiation/detail/reverse_mode_autodiff_basic_operator_overloads.hpp b/include/boost/math/differentiation/detail/reverse_mode_autodiff_basic_operator_expressions.hpp
similarity index 68%
rename from include/boost/math/differentiation/detail/reverse_mode_autodiff_basic_operator_overloads.hpp
rename to include/boost/math/differentiation/detail/reverse_mode_autodiff_basic_operator_expressions.hpp
index 1acb2439f..27a3fdd7d 100644
--- a/include/boost/math/differentiation/detail/reverse_mode_autodiff_basic_operator_overloads.hpp
+++ b/include/boost/math/differentiation/detail/reverse_mode_autodiff_basic_operator_expressions.hpp
@@ -268,148 +268,6 @@ struct const_div_by_expr
 };
 /****************************************************************************************************************/
 
-template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
-mult_expr<RealType, DerivativeOrder, LHS, RHS> operator*(
-    const expression<RealType, DerivativeOrder, LHS> &lhs,
-    const expression<RealType, DerivativeOrder, RHS> &rhs)
-{
-    return mult_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
-}
-
-/** @brief type promotion is handled by casting the numeric type to
- *  the type inside expression. This is to avoid converting the
- *  entire tape in case you have something like double * rvar<float>
- *  */
-template<typename RealType2,
-         typename RealType1,
-         size_t DerivativeOrder,
-         typename ARG,
-         typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
-mult_const_expr<RealType1, DerivativeOrder, ARG> operator*(
-    const expression<RealType1, DerivativeOrder, ARG> &arg, const RealType2 &v)
-{
-    return mult_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
-}
-template<typename RealType2,
-         typename RealType1,
-         size_t DerivativeOrder,
-         typename ARG,
-         typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
-mult_const_expr<RealType1, DerivativeOrder, ARG> operator*(
-    const RealType2 &v, const expression<RealType1, DerivativeOrder, ARG> &arg)
-{
-    return mult_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
-}
-/****************************************************************************************************************/
-/* + */
-template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
-add_expr<RealType, DerivativeOrder, LHS, RHS> operator+(
-    const expression<RealType, DerivativeOrder, LHS> &lhs,
-    const expression<RealType, DerivativeOrder, RHS> &rhs)
-{
-    return add_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
-}
-template<typename RealType2,
-         typename RealType1,
-         size_t DerivativeOrder,
-         typename ARG,
-         typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
-add_const_expr<RealType1, DerivativeOrder, ARG> operator+(
-    const expression<RealType1, DerivativeOrder, ARG> &arg, const RealType2 &v)
-{
-    return add_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
-}
-template<typename RealType2,
-         typename RealType1,
-         size_t DerivativeOrder,
-         typename ARG,
-         typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
-add_const_expr<RealType1, DerivativeOrder, ARG> operator+(
-    const RealType2 &v, const expression<RealType1, DerivativeOrder, ARG> &arg)
-{
-    return add_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
-}
-/****************************************************************************************************************/
-/* - overload */
-/** @brief
- *  negation (-1.0*rvar) */
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-mult_const_expr<RealType, DerivativeOrder, ARG> operator-(
-    const expression<RealType, DerivativeOrder, ARG> &arg)
-{
-    return mult_const_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(-1.0));
-}
-
-/** @brief
- *  subtraction rvar-rvar */
-template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
-sub_expr<RealType, DerivativeOrder, LHS, RHS> operator-(
-    const expression<RealType, DerivativeOrder, LHS> &lhs,
-    const expression<RealType, DerivativeOrder, RHS> &rhs)
-{
-    return sub_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
-}
-
-/** @brief
- *  subtraction float - rvar */
-template<typename RealType2,
-         typename RealType1,
-         size_t DerivativeOrder,
-         typename ARG,
-         typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
-add_const_expr<RealType1, DerivativeOrder, ARG> operator-(
-    const expression<RealType1, DerivativeOrder, ARG> &arg, const RealType2 &v)
-{
-    /* rvar - float = rvar + (-float) */
-    return add_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(-v));
-}
-
-/** @brief
- *   subtraction float - rvar
- *  @return add_expr<neg_expr<ARG>>
- */
-template<typename RealType2,
-         typename RealType1,
-         size_t DerivativeOrder,
-         typename ARG,
-         typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
-auto operator-(const RealType2 &v, const expression<RealType1, DerivativeOrder, ARG> &arg)
-{
-    auto neg = -arg;
-    return neg + static_cast<RealType1>(v);
-}
-/****************************************************************************************************************/
-/* / */
-template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
-div_expr<RealType, DerivativeOrder, LHS, RHS> operator/(
-    const expression<RealType, DerivativeOrder, LHS> &lhs,
-    const expression<RealType, DerivativeOrder, RHS> &rhs)
-{
-    return div_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
-}
-
-template<typename RealType2,
-         typename RealType1,
-         size_t DerivativeOrder,
-         typename ARG,
-         typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
-const_div_by_expr<RealType1, DerivativeOrder, ARG> operator/(
-    const RealType2 &v, const expression<RealType1, DerivativeOrder, ARG> &arg)
-{
-    return const_div_by_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
-}
-
-template<typename RealType2,
-         typename RealType1,
-         size_t DerivativeOrder,
-         typename ARG,
-         typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
-div_by_const_expr<RealType1, DerivativeOrder, ARG> operator/(
-    const expression<RealType1, DerivativeOrder, ARG> &arg, const RealType2 &v)
-{
-    return div_by_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
-}
-
 } // namespace reverse_mode
 } // namespace differentiation
 } // namespace math
diff --git a/include/boost/math/differentiation/detail/reverse_mode_autodiff_basic_ops_et.hpp b/include/boost/math/differentiation/detail/reverse_mode_autodiff_basic_ops_et.hpp
new file mode 100644
index 000000000..4767d1703
--- /dev/null
+++ b/include/boost/math/differentiation/detail/reverse_mode_autodiff_basic_ops_et.hpp
@@ -0,0 +1,160 @@
+//           Copyright Maksym Zhelyenzyakov 2025-2026.
+// Distributed under the Boost Software License, Version 1.0.
+//      (See accompanying file LICENSE_1_0.txt or copy at
+//           https://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef REVERSE_MODE_AUTODIFF_BASIC_OPS_ET_HPP
+#define REVERSE_MODE_AUTODIFF_BASIC_OPS_ET_HPP
+
+#include <boost/math/differentiation/detail/reverse_mode_autodiff_basic_operator_expressions.hpp>
+namespace boost {
+namespace math {
+namespace differentiation {
+namespace reverse_mode {
+template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
+mult_expr<RealType, DerivativeOrder, LHS, RHS> operator*(
+    const expression<RealType, DerivativeOrder, LHS> &lhs,
+    const expression<RealType, DerivativeOrder, RHS> &rhs)
+{
+    return mult_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
+}
+
+/** @brief type promotion is handled by casting the numeric type to
+ *  the type inside expression. This is to avoid converting the
+ *  entire tape in case you have something like double * rvar<float>
+ *  */
+template<typename RealType2,
+         typename RealType1,
+         size_t DerivativeOrder,
+         typename ARG,
+         typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
+mult_const_expr<RealType1, DerivativeOrder, ARG> operator*(
+    const expression<RealType1, DerivativeOrder, ARG> &arg, const RealType2 &v)
+{
+    return mult_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
+}
+template<typename RealType2,
+         typename RealType1,
+         size_t DerivativeOrder,
+         typename ARG,
+         typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
+mult_const_expr<RealType1, DerivativeOrder, ARG> operator*(
+    const RealType2 &v, const expression<RealType1, DerivativeOrder, ARG> &arg)
+{
+    return mult_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
+}
+/****************************************************************************************************************/
+/* + */
+template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
+add_expr<RealType, DerivativeOrder, LHS, RHS> operator+(
+    const expression<RealType, DerivativeOrder, LHS> &lhs,
+    const expression<RealType, DerivativeOrder, RHS> &rhs)
+{
+    return add_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
+}
+template<typename RealType2,
+         typename RealType1,
+         size_t DerivativeOrder,
+         typename ARG,
+         typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
+add_const_expr<RealType1, DerivativeOrder, ARG> operator+(
+    const expression<RealType1, DerivativeOrder, ARG> &arg, const RealType2 &v)
+{
+    return add_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
+}
+template<typename RealType2,
+         typename RealType1,
+         size_t DerivativeOrder,
+         typename ARG,
+         typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
+add_const_expr<RealType1, DerivativeOrder, ARG> operator+(
+    const RealType2 &v, const expression<RealType1, DerivativeOrder, ARG> &arg)
+{
+    return add_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
+}
+/****************************************************************************************************************/
+/* - overload */
+/** @brief
+ *  negation (-1.0*rvar) */
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+mult_const_expr<RealType, DerivativeOrder, ARG> operator-(
+    const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return mult_const_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(-1.0));
+}
+
+/** @brief
+ *  subtraction rvar-rvar */
+template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
+sub_expr<RealType, DerivativeOrder, LHS, RHS> operator-(
+    const expression<RealType, DerivativeOrder, LHS> &lhs,
+    const expression<RealType, DerivativeOrder, RHS> &rhs)
+{
+    return sub_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
+}
+
+/** @brief
+ *  subtraction float - rvar */
+template<typename RealType2,
+         typename RealType1,
+         size_t DerivativeOrder,
+         typename ARG,
+         typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
+add_const_expr<RealType1, DerivativeOrder, ARG> operator-(
+    const expression<RealType1, DerivativeOrder, ARG> &arg, const RealType2 &v)
+{
+    /* rvar - float = rvar + (-float) */
+    return add_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(-v));
+}
+
+/** @brief
+ *   subtraction float - rvar
+ *  @return add_expr<neg_expr<ARG>>
+ */
+template<typename RealType2,
+         typename RealType1,
+         size_t DerivativeOrder,
+         typename ARG,
+         typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
+auto operator-(const RealType2 &v, const expression<RealType1, DerivativeOrder, ARG> &arg)
+{
+    auto neg = -arg;
+    return neg + static_cast<RealType1>(v);
+}
+/****************************************************************************************************************/
+/* / */
+template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
+div_expr<RealType, DerivativeOrder, LHS, RHS> operator/(
+    const expression<RealType, DerivativeOrder, LHS> &lhs,
+    const expression<RealType, DerivativeOrder, RHS> &rhs)
+{
+    return div_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
+}
+
+template<typename RealType2,
+         typename RealType1,
+         size_t DerivativeOrder,
+         typename ARG,
+         typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
+const_div_by_expr<RealType1, DerivativeOrder, ARG> operator/(
+    const RealType2 &v, const expression<RealType1, DerivativeOrder, ARG> &arg)
+{
+    return const_div_by_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
+}
+
+template<typename RealType2,
+         typename RealType1,
+         size_t DerivativeOrder,
+         typename ARG,
+         typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
+div_by_const_expr<RealType1, DerivativeOrder, ARG> operator/(
+    const expression<RealType1, DerivativeOrder, ARG> &arg, const RealType2 &v)
+{
+    return div_by_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
+}
+} // namespace reverse_mode
+} // namespace differentiation
+} // namespace math
+} // namespace boost
+
+#endif // REVERSE_MODE_AUTODIFF_BASIC_OPS_ET_HPP
diff --git a/include/boost/math/differentiation/detail/reverse_mode_autodiff_basic_ops_no_et.hpp b/include/boost/math/differentiation/detail/reverse_mode_autodiff_basic_ops_no_et.hpp
new file mode 100644
index 000000000..21f8cf82a
--- /dev/null
+++ b/include/boost/math/differentiation/detail/reverse_mode_autodiff_basic_ops_no_et.hpp
@@ -0,0 +1,154 @@
+//           Copyright Maksym Zhelyenzyakov 2025-2026.
+// Distributed under the Boost Software License, Version 1.0.
+//      (See accompanying file LICENSE_1_0.txt or copy at
+//           https://www.boost.org/LICENSE_1_0.txt)
+#ifndef REVERSE_MODE_AUTODIFF_BASIC_OPS_NO_ET_HPP
+#define REVERSE_MODE_AUTODIFF_BASIC_OPS_NO_ET_HPP
+#include <boost/math/differentiation/detail/reverse_mode_autodiff_basic_operator_expressions.hpp>
+namespace boost {
+namespace math {
+namespace differentiation {
+namespace reverse_mode {
+
+template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
+rvar<RealType, DerivativeOrder> operator*(const expression<RealType, DerivativeOrder, LHS> &lhs,
+                                          const expression<RealType, DerivativeOrder, RHS> &rhs)
+{
+    return mult_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
+}
+
+/** @brief type promotion is handled by casting the numeric type to
+ *  the type inside expression. This is to avoid converting the
+ *  entire tape in case you have something like double * rvar<float>
+ *  */
+template<typename RealType2,
+         typename RealType1,
+         size_t DerivativeOrder,
+         typename ARG,
+         typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
+rvar<RealType1, DerivativeOrder> operator*(const expression<RealType1, DerivativeOrder, ARG> &arg,
+                                           const RealType2                                   &v)
+{
+    return mult_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
+}
+template<typename RealType2,
+         typename RealType1,
+         size_t DerivativeOrder,
+         typename ARG,
+         typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
+rvar<RealType1, DerivativeOrder> operator*(const RealType2                                   &v,
+                                           const expression<RealType1, DerivativeOrder, ARG> &arg)
+{
+    return mult_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
+}
+/****************************************************************************************************************/
+/* + */
+template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
+rvar<RealType, DerivativeOrder> operator+(const expression<RealType, DerivativeOrder, LHS> &lhs,
+                                          const expression<RealType, DerivativeOrder, RHS> &rhs)
+{
+    return add_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
+}
+template<typename RealType2,
+         typename RealType1,
+         size_t DerivativeOrder,
+         typename ARG,
+         typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
+rvar<RealType1, DerivativeOrder> operator+(const expression<RealType1, DerivativeOrder, ARG> &arg,
+                                           const RealType2                                   &v)
+{
+    return add_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
+}
+template<typename RealType2,
+         typename RealType1,
+         size_t DerivativeOrder,
+         typename ARG,
+         typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
+rvar<RealType1, DerivativeOrder> operator+(const RealType2                                   &v,
+                                           const expression<RealType1, DerivativeOrder, ARG> &arg)
+{
+    return add_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
+}
+/****************************************************************************************************************/
+/* - overload */
+/** @brief
+ *  negation (-1.0*rvar) */
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+rvar<RealType, DerivativeOrder> operator-(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return mult_const_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(-1.0));
+}
+
+/** @brief
+ *  subtraction rvar-rvar */
+template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
+rvar<RealType, DerivativeOrder> operator-(const expression<RealType, DerivativeOrder, LHS> &lhs,
+                                          const expression<RealType, DerivativeOrder, RHS> &rhs)
+{
+    return sub_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
+}
+
+/** @brief
+ *  subtraction float - rvar */
+template<typename RealType2,
+         typename RealType1,
+         size_t DerivativeOrder,
+         typename ARG,
+         typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
+rvar<RealType1, DerivativeOrder> operator-(const expression<RealType1, DerivativeOrder, ARG> &arg,
+                                           const RealType2                                   &v)
+{
+    /* rvar - float = rvar + (-float) */
+    return add_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(-v));
+}
+
+/** @brief
+ *   subtraction float - rvar
+ *  @return add_expr<neg_expr<ARG>>
+ */
+template<typename RealType2,
+         typename RealType1,
+         size_t DerivativeOrder,
+         typename ARG,
+         typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
+rvar<RealType1, DerivativeOrder> operator-(const RealType2                                   &v,
+                                           const expression<RealType1, DerivativeOrder, ARG> &arg)
+{
+    auto neg = -arg;
+    return neg + static_cast<RealType1>(v);
+}
+/****************************************************************************************************************/
+/* / */
+template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
+rvar<RealType, DerivativeOrder> operator/(const expression<RealType, DerivativeOrder, LHS> &lhs,
+                                          const expression<RealType, DerivativeOrder, RHS> &rhs)
+{
+    return div_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
+}
+
+template<typename RealType2,
+         typename RealType1,
+         size_t DerivativeOrder,
+         typename ARG,
+         typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
+rvar<RealType1, DerivativeOrder> operator/(const RealType2                                   &v,
+                                           const expression<RealType1, DerivativeOrder, ARG> &arg)
+{
+    return const_div_by_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
+}
+
+template<typename RealType2,
+         typename RealType1,
+         size_t DerivativeOrder,
+         typename ARG,
+         typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
+rvar<RealType1, DerivativeOrder> operator/(const expression<RealType1, DerivativeOrder, ARG> &arg,
+                                           const RealType2                                   &v)
+{
+    return div_by_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
+}
+} // namespace reverse_mode
+} // namespace differentiation
+} // namespace math
+} // namespace boost
+#endif
diff --git a/include/boost/math/differentiation/detail/reverse_mode_autodiff_erf_overloads.hpp b/include/boost/math/differentiation/detail/reverse_mode_autodiff_erf_overloads.hpp
index 8e6697ae5..37aa26f7b 100644
--- a/include/boost/math/differentiation/detail/reverse_mode_autodiff_erf_overloads.hpp
+++ b/include/boost/math/differentiation/detail/reverse_mode_autodiff_erf_overloads.hpp
@@ -7,7 +7,13 @@
 
 #include <boost/math/constants/constants.hpp>
 #include <boost/math/differentiation/detail/reverse_mode_autodiff_expression_template_base.hpp>
-#include <boost/math/differentiation/detail/reverse_mode_autodiff_stl_overloads.hpp>
+
+#ifdef BOOST_MATH_ET_ON
+#include <boost/math/differentiation/detail/reverse_mode_autodiff_stl_et.hpp>
+#else
+#include <boost/math/differentiation/detail/reverse_mode_autodiff_stl_no_et.hpp>
+#endif
+
 #include <boost/math/differentiation/detail/reverse_mode_autodiff_utilities.hpp>
 #include <boost/math/special_functions/erf.hpp>
 #include <boost/multiprecision/cpp_bin_float.hpp>
diff --git a/include/boost/math/differentiation/detail/reverse_mode_autodiff_stl_et.hpp b/include/boost/math/differentiation/detail/reverse_mode_autodiff_stl_et.hpp
new file mode 100644
index 000000000..8ef304f3b
--- /dev/null
+++ b/include/boost/math/differentiation/detail/reverse_mode_autodiff_stl_et.hpp
@@ -0,0 +1,275 @@
+//           Copyright Maksym Zhelyenzyakov 2025-2026.
+// Distributed under the Boost Software License, Version 1.0.
+//      (See accompanying file LICENSE_1_0.txt or copy at
+//           https://www.boost.org/LICENSE_1_0.txt)
+#ifndef REVERSE_MODE_AUTODIFF_STL_ET_HPP
+#define REVERSE_MODE_AUTODIFF_STL_ET_HPP
+
+#include <boost/math/differentiation/detail/reverse_mode_autodiff_stl_expressions.hpp>
+namespace boost {
+namespace math {
+namespace differentiation {
+namespace reverse_mode {
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+fabs_expr<RealType, DerivativeOrder, ARG> fabs(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return fabs_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+}
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+auto abs(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return fabs(arg);
+}
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+ceil_expr<RealType, DerivativeOrder, ARG> ceil(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return ceil_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+}
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+floor_expr<RealType, DerivativeOrder, ARG> floor(
+    const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return floor_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+exp_expr<RealType, DerivativeOrder, ARG> exp(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return exp_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+}
+
+template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
+pow_expr<RealType, DerivativeOrder, LHS, RHS> pow(
+    const expression<RealType, DerivativeOrder, LHS> &lhs,
+    const expression<RealType, DerivativeOrder, RHS> &rhs)
+{
+    return pow_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
+}
+
+template<typename RealType2,
+         typename RealType1,
+         size_t DerivativeOrder,
+         typename ARG,
+         typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
+expr_pow_float_expr<RealType1, DerivativeOrder, ARG> pow(
+    const expression<RealType1, DerivativeOrder, ARG> &arg, const RealType2 &v)
+{
+    return expr_pow_float_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
+};
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+float_pow_expr_expr<RealType, DerivativeOrder, ARG> pow(
+    const RealType &v, const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return float_pow_expr_expr<RealType, DerivativeOrder, ARG>(arg, v);
+};
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+log_expr<RealType, DerivativeOrder, ARG> log(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return log_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+};
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+sqrt_expr<RealType, DerivativeOrder, ARG> sqrt(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return sqrt_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+};
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+auto frexp(const expression<RealType, DerivativeOrder, ARG> &arg, int *i)
+{
+    BOOST_MATH_STD_USING
+    frexp(arg.evaluate(), i);
+    return arg / pow(static_cast<RealType>(2.0), *i);
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+auto ldexp(const expression<RealType, DerivativeOrder, ARG> &arg, const int &i)
+{
+    BOOST_MATH_STD_USING
+    return arg * pow(static_cast<RealType>(2.0), i);
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+cos_expr<RealType, DerivativeOrder, ARG> cos(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return cos_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+};
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+sin_expr<RealType, DerivativeOrder, ARG> sin(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return sin_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+};
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+tan_expr<RealType, DerivativeOrder, ARG> tan(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return tan_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+};
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+acos_expr<RealType, DerivativeOrder, ARG> acos(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return acos_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+};
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+asin_expr<RealType, DerivativeOrder, ARG> asin(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return asin_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+};
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+atan_expr<RealType, DerivativeOrder, ARG> atan(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return atan_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+};
+
+template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
+atan2_expr<RealType, DerivativeOrder, LHS, RHS> atan2(
+    const expression<RealType, DerivativeOrder, LHS> &lhs,
+    const expression<RealType, DerivativeOrder, RHS> &rhs)
+{
+    return atan2_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+atan2_right_float_expr<RealType, DerivativeOrder, ARG> atan2(
+    const expression<RealType, DerivativeOrder, ARG> &arg, const RealType &v)
+{
+    return atan2_right_float_expr<RealType, DerivativeOrder, ARG>(arg, v);
+};
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+atan2_left_float_expr<RealType, DerivativeOrder, ARG> atan2(
+    const RealType &v, const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return atan2_left_float_expr<RealType, DerivativeOrder, ARG>(arg, v);
+};
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+trunc_expr<RealType, DerivativeOrder, ARG> trunc(
+    const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return trunc_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+}
+
+template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
+auto fmod(const expression<RealType, DerivativeOrder, LHS> &lhs,
+          const expression<RealType, DerivativeOrder, RHS> &rhs)
+{
+    return fmod_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+auto fmod(const expression<RealType, DerivativeOrder, ARG> &lhs, const RealType rhs)
+{
+    return fmod_right_float_expr<RealType, DerivativeOrder, ARG>(lhs, rhs);
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+auto fmod(const RealType lhs, const expression<RealType, DerivativeOrder, ARG> &rhs)
+{
+    return fmod_left_float_expr<RealType, DerivativeOrder, ARG>(rhs, lhs);
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+round_expr<RealType, DerivativeOrder, ARG> round(
+    const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return round_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+int iround(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
+    return iround(tmp.item());
+}
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+long lround(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    BOOST_MATH_STD_USING
+    rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
+    return lround(tmp.item());
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+long long llround(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
+    return llround(tmp.item());
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+int itrunc(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
+    return itrunc(tmp.item());
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+long ltrunc(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
+    return ltrunc(tmp.item());
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+long long lltrunc(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
+    return lltrunc(tmp.item());
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+sinh_expr<RealType, DerivativeOrder, ARG> sinh(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return sinh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+cosh_expr<RealType, DerivativeOrder, ARG> cosh(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return cosh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+tanh_expr<RealType, DerivativeOrder, ARG> tanh(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return tanh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+log10_expr<RealType, DerivativeOrder, ARG> log10(
+    const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return log10_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+}
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+asinh_expr<RealType, DerivativeOrder, ARG> asinh(
+    const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return asinh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+}
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+acosh_expr<RealType, DerivativeOrder, ARG> acosh(
+    const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return acosh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+}
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+atanh_expr<RealType, DerivativeOrder, ARG> atanh(
+    const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return atanh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+}
+} // namespace reverse_mode
+} // namespace differentiation
+} // namespace math
+} // namespace boost
+
+#endif
diff --git a/include/boost/math/differentiation/detail/reverse_mode_autodiff_stl_overloads.hpp b/include/boost/math/differentiation/detail/reverse_mode_autodiff_stl_expressions.hpp
similarity index 76%
rename from include/boost/math/differentiation/detail/reverse_mode_autodiff_stl_overloads.hpp
rename to include/boost/math/differentiation/detail/reverse_mode_autodiff_stl_expressions.hpp
index aa8716d4a..0acc2e6b0 100644
--- a/include/boost/math/differentiation/detail/reverse_mode_autodiff_stl_overloads.hpp
+++ b/include/boost/math/differentiation/detail/reverse_mode_autodiff_stl_expressions.hpp
@@ -5,7 +5,13 @@
 #ifndef REVERSE_MODE_AUTODIFF_STL_OVERLOADS
 #define REVERSE_MODE_AUTODIFF_STL_OVERLOADS
 /* stl support : expressions */
-#include <boost/math/differentiation/detail/reverse_mode_autodiff_basic_operator_overloads.hpp>
+
+#ifdef BOOST_MATH_ET_ON
+#include <boost/math/differentiation/detail/reverse_mode_autodiff_basic_ops_et.hpp>
+#else
+#include <boost/math/differentiation/detail/reverse_mode_autodiff_basic_ops_no_et.hpp>
+#endif
+
 #include <boost/math/differentiation/detail/reverse_mode_autodiff_expression_template_base.hpp>
 #include <boost/math/special_functions/round.hpp>
 #include <boost/math/special_functions/trunc.hpp>
@@ -836,249 +842,7 @@ struct fmod_right_float_expr
     }
 };
 /**************************************************************************************************/
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-fabs_expr<RealType, DerivativeOrder, ARG> fabs(const expression<RealType,DerivativeOrder, ARG> &arg)
-{
-    return fabs_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
-}
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-auto abs(const expression<RealType, DerivativeOrder, ARG> &arg)
-{
-    return fabs(arg);
-}
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-ceil_expr<RealType, DerivativeOrder, ARG> ceil(const expression<RealType,DerivativeOrder, ARG> &arg)
-{
-    return ceil_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
-}
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-floor_expr<RealType, DerivativeOrder, ARG> floor(const expression<RealType,DerivativeOrder, ARG> &arg)
-{
-    return floor_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
-}
 
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-exp_expr<RealType, DerivativeOrder, ARG> exp(const expression<RealType,DerivativeOrder, ARG> &arg)
-{
-    return exp_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
-}
-
-template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
-pow_expr<RealType, DerivativeOrder, LHS, RHS> pow(const expression<RealType, DerivativeOrder, LHS> &lhs,
-                                 const expression<RealType, DerivativeOrder, RHS> &rhs)
-{
-    return pow_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
-}
-
-template<typename RealType2,
-         typename RealType1,
-         size_t DerivativeOrder,
-         typename ARG,
-         typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
-expr_pow_float_expr<RealType1, DerivativeOrder, ARG> pow(
-    const expression<RealType1, DerivativeOrder, ARG> &arg, const RealType2 &v)
-{
-    return expr_pow_float_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
-};
-
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-float_pow_expr_expr<RealType, DerivativeOrder, ARG> pow(const RealType &v, const expression<RealType,DerivativeOrder, ARG> &arg)
-{
-    return float_pow_expr_expr<RealType, DerivativeOrder, ARG>(arg, v);
-};
-
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-log_expr<RealType, DerivativeOrder, ARG> log(const expression<RealType,DerivativeOrder, ARG> &arg)
-{
-    return log_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
-};
-
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-sqrt_expr<RealType, DerivativeOrder, ARG> sqrt(const expression<RealType,DerivativeOrder, ARG> &arg)
-{
-    return sqrt_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
-};
-
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-auto frexp(const expression<RealType, DerivativeOrder, ARG> &arg, int *i)
-{
-    BOOST_MATH_STD_USING
-    frexp(arg.evaluate(), i);
-    return arg / pow(static_cast<RealType>(2.0), *i);
-}
-
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-auto ldexp(const expression<RealType, DerivativeOrder, ARG> &arg, const int &i)
-{
-    BOOST_MATH_STD_USING
-    return arg * pow(static_cast<RealType>(2.0), i);
-}
-
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-cos_expr<RealType, DerivativeOrder, ARG> cos(const expression<RealType,DerivativeOrder, ARG> &arg)
-{
-    return cos_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
-};
-
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-sin_expr<RealType, DerivativeOrder, ARG> sin(const expression<RealType,DerivativeOrder, ARG> &arg)
-{
-    return sin_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
-};
-
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-tan_expr<RealType, DerivativeOrder, ARG> tan(const expression<RealType,DerivativeOrder, ARG> &arg)
-{
-    return tan_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
-};
-
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-acos_expr<RealType, DerivativeOrder, ARG> acos(const expression<RealType,DerivativeOrder, ARG> &arg)
-{
-    return acos_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
-};
-
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-asin_expr<RealType, DerivativeOrder, ARG> asin(const expression<RealType,DerivativeOrder, ARG> &arg)
-{
-    return asin_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
-};
-
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-atan_expr<RealType, DerivativeOrder, ARG> atan(const expression<RealType,DerivativeOrder, ARG> &arg)
-{
-    return atan_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
-};
-
-template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
-atan2_expr<RealType, DerivativeOrder, LHS, RHS> atan2(const expression<RealType, DerivativeOrder, LHS> &lhs,
-                                     const expression<RealType, DerivativeOrder, RHS> &rhs)
-{
-    return atan2_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
-}
-
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-atan2_right_float_expr<RealType, DerivativeOrder, ARG> atan2(const expression<RealType,DerivativeOrder, ARG> &arg, const RealType &v)
-{
-    return atan2_right_float_expr<RealType, DerivativeOrder, ARG>(arg, v);
-};
-
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-atan2_left_float_expr<RealType, DerivativeOrder, ARG> atan2(const RealType &v, const expression<RealType,DerivativeOrder, ARG> &arg)
-{
-    return atan2_left_float_expr<RealType, DerivativeOrder, ARG>(arg, v);
-};
-
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-trunc_expr<RealType, DerivativeOrder, ARG> trunc(const expression<RealType,DerivativeOrder, ARG> &arg)
-{
-    return trunc_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
-}
-
-template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
-auto fmod(const expression<RealType, DerivativeOrder, LHS> &lhs, const expression<RealType, DerivativeOrder, RHS> &rhs)
-{
-    return fmod_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
-}
-
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-auto fmod(const expression<RealType, DerivativeOrder, ARG> &lhs, const RealType rhs)
-{
-    return fmod_right_float_expr<RealType, DerivativeOrder, ARG>(lhs, rhs);
-}
-
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-auto fmod(const RealType lhs, const expression<RealType, DerivativeOrder, ARG> &rhs)
-{
-    return fmod_left_float_expr<RealType, DerivativeOrder, ARG>(rhs, lhs);
-}
-
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-round_expr<RealType, DerivativeOrder, ARG> round(const expression<RealType,DerivativeOrder, ARG> &arg)
-{
-    return round_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
-}
-
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-int iround(const expression<RealType, DerivativeOrder, ARG> &arg)
-{
-    rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
-    return iround(tmp.item());
-}
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-long lround(const expression<RealType, DerivativeOrder, ARG> &arg)
-{
-    BOOST_MATH_STD_USING
-    rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
-    return lround(tmp.item());
-}
-
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-long long llround(const expression<RealType, DerivativeOrder, ARG> &arg)
-{
-    rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
-    return llround(tmp.item());
-}
-
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-int itrunc(const expression<RealType, DerivativeOrder, ARG> &arg)
-{
-    rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
-    return itrunc(tmp.item());
-}
-
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-long ltrunc(const expression<RealType, DerivativeOrder, ARG> &arg)
-{
-    rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
-    return ltrunc(tmp.item());
-}
-
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-long long lltrunc(const expression<RealType, DerivativeOrder, ARG> &arg)
-{
-    rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
-    return lltrunc(tmp.item());
-}
-
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-sinh_expr<RealType, DerivativeOrder, ARG> sinh(const expression<RealType,DerivativeOrder, ARG> &arg)
-{
-    return sinh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
-}
-
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-cosh_expr<RealType, DerivativeOrder, ARG> cosh(const expression<RealType,DerivativeOrder, ARG> &arg)
-{
-    return cosh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
-}
-
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-tanh_expr<RealType, DerivativeOrder, ARG> tanh(const expression<RealType,DerivativeOrder, ARG> &arg)
-{
-    return tanh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
-}
-
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-log10_expr<RealType, DerivativeOrder, ARG> log10(const expression<RealType,DerivativeOrder, ARG> &arg)
-{
-    return log10_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
-}
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-asinh_expr<RealType, DerivativeOrder, ARG> asinh(const expression<RealType,DerivativeOrder, ARG> &arg)
-{
-    return asinh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
-}
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-acosh_expr<RealType, DerivativeOrder, ARG> acosh(const expression<RealType,DerivativeOrder, ARG> &arg)
-{
-    return acosh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
-}
-template<typename RealType, size_t DerivativeOrder, typename ARG>
-atanh_expr<RealType, DerivativeOrder, ARG> atanh(const expression<RealType,DerivativeOrder, ARG> &arg)
-{
-    return atanh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
-}
 } // namespace reverse_mode
 } // namespace differentiation
 } // namespace math
diff --git a/include/boost/math/differentiation/detail/reverse_mode_autodiff_stl_no_et.hpp b/include/boost/math/differentiation/detail/reverse_mode_autodiff_stl_no_et.hpp
new file mode 100644
index 000000000..15498a127
--- /dev/null
+++ b/include/boost/math/differentiation/detail/reverse_mode_autodiff_stl_no_et.hpp
@@ -0,0 +1,266 @@
+//           Copyright Maksym Zhelyenzyakov 2025-2026.
+// Distributed under the Boost Software License, Version 1.0.
+//      (See accompanying file LICENSE_1_0.txt or copy at
+//           https://www.boost.org/LICENSE_1_0.txt)
+#ifndef REVERSE_MODE_AUTODIFF_STL_NO_ET_HPP
+#define REVERSE_MODE_AUTODIFF_STL_NO_ET_HPP
+
+#include <boost/math/differentiation/detail/reverse_mode_autodiff_stl_expressions.hpp>
+namespace boost {
+namespace math {
+namespace differentiation {
+namespace reverse_mode {
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+rvar<RealType, DerivativeOrder> fabs(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return fabs_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+}
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+rvar<RealType, DerivativeOrder> abs(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return fabs(arg);
+}
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+rvar<RealType, DerivativeOrder> ceil(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return ceil_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+}
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+rvar<RealType, DerivativeOrder> floor(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return floor_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+rvar<RealType, DerivativeOrder> exp(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return exp_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+}
+
+template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
+rvar<RealType, DerivativeOrder> pow(const expression<RealType, DerivativeOrder, LHS> &lhs,
+                                    const expression<RealType, DerivativeOrder, RHS> &rhs)
+{
+    return pow_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
+}
+
+template<typename RealType2,
+         typename RealType1,
+         size_t DerivativeOrder,
+         typename ARG,
+         typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
+rvar<RealType1, DerivativeOrder> pow(const expression<RealType1, DerivativeOrder, ARG> &arg,
+                                     const RealType2                                   &v)
+{
+    return expr_pow_float_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
+};
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+rvar<RealType, DerivativeOrder> pow(const RealType                                   &v,
+                                    const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return float_pow_expr_expr<RealType, DerivativeOrder, ARG>(arg, v);
+};
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+rvar<RealType, DerivativeOrder> log(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return log_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+};
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+rvar<RealType, DerivativeOrder> sqrt(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return sqrt_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+};
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+rvar<RealType, DerivativeOrder> frexp(const expression<RealType, DerivativeOrder, ARG> &arg, int *i)
+{
+    BOOST_MATH_STD_USING
+    frexp(arg.evaluate(), i);
+    return arg / pow(static_cast<RealType>(2.0), *i);
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+auto ldexp(const expression<RealType, DerivativeOrder, ARG> &arg, const int &i)
+{
+    BOOST_MATH_STD_USING
+    return arg * pow(static_cast<RealType>(2.0), i);
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+rvar<RealType, DerivativeOrder> cos(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return cos_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+};
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+rvar<RealType, DerivativeOrder> sin(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return sin_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+};
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+rvar<RealType, DerivativeOrder> tan(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return tan_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+};
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+rvar<RealType, DerivativeOrder> acos(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return acos_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+};
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+rvar<RealType, DerivativeOrder> asin(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return asin_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+};
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+rvar<RealType, DerivativeOrder> atan(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return atan_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+};
+
+template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
+rvar<RealType, DerivativeOrder> atan2(const expression<RealType, DerivativeOrder, LHS> &lhs,
+                                      const expression<RealType, DerivativeOrder, RHS> &rhs)
+{
+    return atan2_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+rvar<RealType, DerivativeOrder> atan2(const expression<RealType, DerivativeOrder, ARG> &arg,
+                                      const RealType                                   &v)
+{
+    return atan2_right_float_expr<RealType, DerivativeOrder, ARG>(arg, v);
+};
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+rvar<RealType, DerivativeOrder> atan2(const RealType                                   &v,
+                                      const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return atan2_left_float_expr<RealType, DerivativeOrder, ARG>(arg, v);
+};
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+rvar<RealType, DerivativeOrder> trunc(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return trunc_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+}
+
+template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
+auto fmod(const expression<RealType, DerivativeOrder, LHS> &lhs,
+          const expression<RealType, DerivativeOrder, RHS> &rhs)
+{
+    return fmod_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+auto fmod(const expression<RealType, DerivativeOrder, ARG> &lhs, const RealType rhs)
+{
+    return fmod_right_float_expr<RealType, DerivativeOrder, ARG>(lhs, rhs);
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+auto fmod(const RealType lhs, const expression<RealType, DerivativeOrder, ARG> &rhs)
+{
+    return fmod_left_float_expr<RealType, DerivativeOrder, ARG>(rhs, lhs);
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+rvar<RealType, DerivativeOrder> round(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return round_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+int iround(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
+    return iround(tmp.item());
+}
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+long lround(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    BOOST_MATH_STD_USING
+    rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
+    return lround(tmp.item());
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+long long llround(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
+    return llround(tmp.item());
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+int itrunc(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
+    return itrunc(tmp.item());
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+long ltrunc(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
+    return ltrunc(tmp.item());
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+long long lltrunc(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
+    return lltrunc(tmp.item());
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+rvar<RealType, DerivativeOrder> sinh(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return sinh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+rvar<RealType, DerivativeOrder> cosh(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return cosh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+rvar<RealType, DerivativeOrder> tanh(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return tanh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+}
+
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+rvar<RealType, DerivativeOrder> log10(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return log10_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+}
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+rvar<RealType, DerivativeOrder> asinh(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return asinh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+}
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+rvar<RealType, DerivativeOrder> acosh(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return acosh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+}
+template<typename RealType, size_t DerivativeOrder, typename ARG>
+rvar<RealType, DerivativeOrder> atanh(const expression<RealType, DerivativeOrder, ARG> &arg)
+{
+    return atanh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
+}
+} // namespace reverse_mode
+} // namespace differentiation
+} // namespace math
+} // namespace boost
+
+#endif