diff --git a/docs/flows.adoc b/docs/flows.adoc
index c2aac339..0c1ae0e9 100644
--- a/docs/flows.adoc
+++ b/docs/flows.adoc
@@ -44,11 +44,11 @@ Actions are added to the flow inside a component's `cib::config`.
 struct morning {
   constexpr auto config = cib::config(
     cib::extend<MorningRoutine>(
-        WAKE_UP >>
-        selfcare::SHOWER >>
-        selfcare::GET_DRESSED >>
-        food::MAKE_COFFEE >>
-        food::DRINK_COFFEE));
+        *WAKE_UP >>
+        *selfcare::SHOWER >>
+        *selfcare::GET_DRESSED >>
+        *food::MAKE_COFFEE >>
+        *food::DRINK_COFFEE));
 };
 ----
 
@@ -58,6 +58,17 @@ a shower. The flow library will order actions in a flow to respect these
 dependencies. The actions will be executed in an order that respects all given
 dependencies.
 
+The `*` operator is used to explicitly add an action to the
+flow. Without the `*` operator an action is just a reference.
+A compile-time error will be triggered if an action is referenced without ever
+being explicitly added to the flow. If an action is added under a compile-time
+or runtime conditional, and the conditional is false, then it is as if the
+action was never added at all.
+
+The behavior of the `*` operator ensures that merely referencing an 
+action to create an ordering dependency doesn't unintentionally add the action
+to the flow.
+
 If we only use the `morning` component in our project, the `MorningRoutine` flow
 graph would look like the following:
 
@@ -93,11 +104,11 @@ struct childcare {
   constexpr auto config = cib::config(
       cib::extend<MorningRoutine>(
           food::MAKE_COFFEE >>          // this step exists in the MorningRoutine flow
-          PACK_SCHOOL_LUNCHES >>        // new
+          *PACK_SCHOOL_LUNCHES >>       // new
           food::DRINK_COFFEE >>         // existing
-          food::MAKE_BREAKFAST >>       // new
-          food::EAT_BREAKFAST >>        // new
-          SEND_KIDS_TO_SCHOOL));        // new
+          *food::MAKE_BREAKFAST >>      // new
+          *food::EAT_BREAKFAST >>       // new
+          *SEND_KIDS_TO_SCHOOL));       // new
 };
 ----
 
@@ -140,7 +151,7 @@ struct exercise {
   constexpr auto config = cib::config(
       cib::extend<MorningRoutine>(
           morning::WAKE_UP >>
-          RIDE_STATIONARY_BIKE >>
+          *RIDE_STATIONARY_BIKE >>
           selfcare::SHOWER));
 };
 ----
@@ -321,7 +332,47 @@ namespace example_component {
   constexpr auto config = cib::config(
       cib::extend<MyFlow>(
           // no order requirement between these actions
-          SOME_ACTION && SOME_OTHER_ACTION));
+          *SOME_ACTION && *SOME_OTHER_ACTION));
+}
+----
+
+==== `operator*`
+
+Explicitly add an action to the flow. Actions used in flow extensions without
+the `*` will be treated as references only and will not be added to the
+flow at that location. It is a compilation error if an action is not added 
+with a `*` in exactly one location in the overall config.
+
+Actions can be added and ordered all at once:
+
+[source,cpp]
+----
+namespace example_component {
+  constexpr auto config = cib::config(
+      cib::extend<MyFlow>(
+          // Add both actions and create an ordering between them.
+          *SOME_ACTION >> *SOME_OTHER_ACTION));
+}
+----
+
+Actions can also be added and ordered seperately:
+
+[source,cpp]
+----
+namespace other_component {
+  constexpr auto INIT_SOMETHING = ...
+
+  constexpr auto config = cib::config(
+      cib::extend<MyFlow>(*INIT_SOMETHING));
+}
+
+namespace example_component {
+  constexpr auto DO_A_THING = ...
+
+  constexpr auto config = cib::config(
+      cib::extend<MyFlow>(
+          other_component::INIT_SOMETHING >> 
+          *DO_A_THING));
 }
 ----
 
diff --git a/examples/flow_daily_routine/main.cpp b/examples/flow_daily_routine/main.cpp
index 978d250d..7b94d43c 100644
--- a/examples/flow_daily_routine/main.cpp
+++ b/examples/flow_daily_routine/main.cpp
@@ -95,14 +95,10 @@ struct self_care_component_t {
     // Extend flow services
     constexpr static auto config = cib::config(
 
-        cib::extend<morning_routine_t>(self_care_component_t::WAKE_UP >>
-                                       self_care_component_t::EXERCISE >>
-                                       self_care_component_t::TAKE_BATH),
+        cib::extend<morning_routine_t>(*WAKE_UP >> *EXERCISE >> *TAKE_BATH),
 
-        cib::extend<evening_routine_t>(self_care_component_t::EXERCISE >>
-                                       self_care_component_t::TAKE_BATH >>
-                                       self_care_component_t::RELAX >>
-                                       self_care_component_t::GO_TO_BED));
+        cib::extend<evening_routine_t>(*EXERCISE >> *TAKE_BATH >> *RELAX >>
+                                       *GO_TO_BED));
 };
 
 struct food_component_t {
@@ -119,10 +115,10 @@ struct food_component_t {
     constexpr static auto config = cib::config(
 
         cib::extend<morning_routine_t>(self_care_component_t::TAKE_BATH >>
-                                       food_component_t::BREAKFAST),
+                                       *BREAKFAST),
 
         cib::extend<evening_routine_t>(self_care_component_t::RELAX >>
-                                       food_component_t::DINNER >>
+                                       *DINNER >>
                                        self_care_component_t::GO_TO_BED));
 };
 
@@ -141,16 +137,13 @@ struct dress_up_component_t {
     constexpr static auto config = cib::config(
 
         cib::extend<morning_routine_t>(
-            self_care_component_t::WAKE_UP >>
-            dress_up_component_t::GET_READY_FOR_EXERCISE >>
+            self_care_component_t::WAKE_UP >> *GET_READY_FOR_EXERCISE >>
             self_care_component_t::EXERCISE >>
-            self_care_component_t::TAKE_BATH >>
-            dress_up_component_t::GET_READY_TO_WORK >>
+            self_care_component_t::TAKE_BATH >> *GET_READY_TO_WORK >>
             food_component_t::BREAKFAST),
 
-        cib::extend<evening_routine_t>(
-            dress_up_component_t::GET_READY_FOR_EXERCISE >>
-            self_care_component_t::EXERCISE));
+        cib::extend<evening_routine_t>(*GET_READY_FOR_EXERCISE >>
+                                       self_care_component_t::EXERCISE));
 };
 
 struct commute_component_t {
@@ -167,11 +160,10 @@ struct commute_component_t {
     constexpr static auto config = cib::config(
 
         cib::extend<morning_routine_t>(food_component_t::BREAKFAST >>
-                                       commute_component_t::GO_TO_OFFICE),
+                                       *GO_TO_OFFICE),
 
         cib::extend<evening_routine_t>(
-            commute_component_t::RETURN_HOME >>
-            dress_up_component_t::GET_READY_FOR_EXERCISE));
+            *RETURN_HOME >> dress_up_component_t::GET_READY_FOR_EXERCISE));
 };
 
 struct daily_routine_component_t {
@@ -206,7 +198,7 @@ struct daily_routine_component_t {
 
         // we need to extend the MainLoop as cib::top implements
         // MainLoop service
-        cib::extend<cib::MainLoop>(DAILY_ROUTINES));
+        cib::extend<cib::MainLoop>(*DAILY_ROUTINES));
 };
 
 struct person_routine_proj {
diff --git a/include/cib/config.hpp b/include/cib/config.hpp
index d08bb896..cd8fd7e9 100644
--- a/include/cib/config.hpp
+++ b/include/cib/config.hpp
@@ -7,6 +7,7 @@
 #include <cib/detail/config_item.hpp>
 #include <cib/detail/exports.hpp>
 #include <cib/detail/extend.hpp>
+#include <cib/detail/runtime_conditional.hpp>
 
 #include <stdx/compiler.hpp>
 
@@ -22,6 +23,7 @@ namespace cib {
  * @see cib::extend
  * @see cib::exports
  * @see cib::conditional
+ * @see cib::runtime_conditional
  */
 template <typename... Configs>
 [[nodiscard]] CONSTEVAL auto config(Configs const &...configs) {
@@ -72,4 +74,10 @@ template <typename Predicate, typename... Configs>
                                          Configs const &...configs) {
     return detail::conditional<Predicate, Configs...>{configs...};
 }
+
+template <stdx::ct_string Name>
+constexpr auto runtime_condition = []<typename P>(P) {
+    static_assert(std::is_default_constructible_v<P>);
+    return detail::runtime_condition<Name, P>{};
+};
 } // namespace cib
diff --git a/include/cib/detail/runtime_conditional.hpp b/include/cib/detail/runtime_conditional.hpp
new file mode 100644
index 00000000..29ba2f56
--- /dev/null
+++ b/include/cib/detail/runtime_conditional.hpp
@@ -0,0 +1,89 @@
+#pragma once
+
+#include <cib/detail/config_details.hpp>
+#include <cib/detail/config_item.hpp>
+#include <cib/detail/extend.hpp>
+
+#include <stdx/compiler.hpp>
+#include <stdx/ct_format.hpp>
+#include <stdx/tuple.hpp>
+#include <stdx/tuple_algorithms.hpp>
+
+namespace cib::detail {
+namespace poison {
+template <typename... Ts>
+constexpr auto make_runtime_conditional(Ts &&...) = delete;
+}
+
+template <typename Cond, typename... Configs>
+struct runtime_conditional : config_item {
+    detail::config<Configs...> body;
+
+    CONSTEVAL explicit runtime_conditional(Configs const &...configs)
+        : body{configs...} {}
+
+    [[nodiscard]] constexpr auto extends_tuple() const {
+        return stdx::transform(
+            []<typename E>(E e) {
+                auto args_tuple = stdx::transform(
+                    []<typename Arg>(Arg) {
+                        using poison::make_runtime_conditional;
+                        return make_runtime_conditional(Cond{}, Arg{});
+                    },
+                    e.args_tuple);
+
+                return stdx::apply(
+                    []<typename... Args>(Args...) {
+                        return extend<typename E::service_type, Args...>{
+                            Args{}...};
+                    },
+                    args_tuple);
+            },
+            body.extends_tuple());
+    }
+
+    [[nodiscard]] constexpr auto exports_tuple() const {
+        return body.exports_tuple();
+    }
+};
+
+template <stdx::ct_string Name, typename... Ps> // FIXME: concept for Ps
+struct runtime_condition {
+    constexpr static auto predicates = stdx::make_tuple(Ps{}...);
+
+    constexpr static auto ct_name = Name;
+
+    template <typename... Configs>
+    [[nodiscard]] CONSTEVAL auto operator()(Configs const &...configs) const {
+        return detail::runtime_conditional<runtime_condition<Name, Ps...>,
+                                           Configs...>{configs...};
+    }
+
+    explicit operator bool() const { return (Ps{}() and ...); }
+};
+
+template <stdx::ct_string LhsName, typename... LhsPs, stdx::ct_string RhsName,
+          typename... RhsPs>
+[[nodiscard]] constexpr auto
+operator and(runtime_condition<LhsName, LhsPs...> const &lhs,
+             runtime_condition<RhsName, RhsPs...> const &rhs) {
+    if constexpr ((sizeof...(LhsPs) + sizeof...(RhsPs)) == 0) {
+        return runtime_condition<"always">{};
+
+    } else if constexpr (sizeof...(LhsPs) == 0) {
+        return rhs;
+
+    } else if constexpr (sizeof...(RhsPs) == 0) {
+        return lhs;
+
+    } else {
+        constexpr auto name =
+            stdx::ct_format<"{} and {}">(CX_VALUE(LhsName), CX_VALUE(RhsName));
+
+        return runtime_condition<name, LhsPs..., RhsPs...>{};
+    }
+}
+
+using always_condition_t = runtime_condition<"always">;
+constexpr auto always_condition = always_condition_t{};
+} // namespace cib::detail
diff --git a/include/flow/builder.hpp b/include/flow/builder.hpp
index c2048f7a..b9113640 100644
--- a/include/flow/builder.hpp
+++ b/include/flow/builder.hpp
@@ -9,7 +9,7 @@
 
 namespace flow {
 template <stdx::ct_string Name = "">
-using builder = graph<Name, graph_builder<impl>>;
+using builder = graph<Name, graph_builder<Name, impl>>;
 
 template <stdx::ct_string Name = "">
 struct service : cib::builder_meta<builder<Name>, FunctionPtr> {};
diff --git a/include/flow/detail/par.hpp b/include/flow/detail/par.hpp
index 287ac7e2..17912667 100644
--- a/include/flow/detail/par.hpp
+++ b/include/flow/detail/par.hpp
@@ -1,15 +1,22 @@
 #pragma once
 
 #include <flow/detail/walk.hpp>
+#include <flow/subgraph_identity.hpp>
 
 #include <stdx/tuple_algorithms.hpp>
 
 namespace flow::dsl {
-template <node Lhs, node Rhs> struct par {
+template <subgraph Lhs, subgraph Rhs,
+          subgraph_identity Identity = subgraph_identity::REFERENCE>
+struct par {
     Lhs lhs;
     Rhs rhs;
 
-    using is_node = void;
+    using is_subgraph = void;
+
+    constexpr auto operator*() const {
+        return par<Lhs, Rhs, subgraph_identity::VALUE>{Lhs{}, Rhs{}};
+    }
 
   private:
     friend constexpr auto tag_invoke(get_initials_t, par const &p) {
@@ -21,7 +28,21 @@ template <node Lhs, node Rhs> struct par {
     }
 
     friend constexpr auto tag_invoke(get_nodes_t, par const &p) {
-        return stdx::tuple_cat(get_nodes(p.lhs), get_nodes(p.rhs));
+        if constexpr (Identity == subgraph_identity::VALUE) {
+            auto all_nodes = stdx::to_unsorted_set(
+                stdx::tuple_cat(get_all_mentioned_nodes(p.lhs),
+                                get_all_mentioned_nodes(p.rhs)));
+
+            return stdx::transform([](auto const &n) { return *n; }, all_nodes);
+
+        } else {
+            return stdx::tuple_cat(get_nodes(p.lhs), get_nodes(p.rhs));
+        }
+    }
+
+    friend constexpr auto tag_invoke(get_all_mentioned_nodes_t, par const &p) {
+        return stdx::tuple_cat(get_all_mentioned_nodes(p.lhs),
+                               get_all_mentioned_nodes(p.rhs));
     }
 
     friend constexpr auto tag_invoke(get_edges_t, par const &p) {
@@ -29,10 +50,23 @@ template <node Lhs, node Rhs> struct par {
     }
 };
 
-template <node Lhs, node Rhs> par(Lhs, Rhs) -> par<Lhs, Rhs>;
+template <subgraph Lhs, subgraph Rhs> par(Lhs, Rhs) -> par<Lhs, Rhs>;
 } // namespace flow::dsl
 
-template <flow::dsl::node Lhs, flow::dsl::node Rhs>
+template <flow::dsl::subgraph Lhs, flow::dsl::subgraph Rhs>
 [[nodiscard]] constexpr auto operator&&(Lhs const &lhs, Rhs const &rhs) {
     return flow::dsl::par{lhs, rhs};
 }
+
+template <typename Cond, flow::dsl::subgraph Lhs, flow::dsl::subgraph Rhs,
+          flow::subgraph_identity Identity>
+constexpr auto make_runtime_conditional(Cond,
+                                        flow::dsl::par<Lhs, Rhs, Identity>) {
+    auto lhs = make_runtime_conditional(Cond{}, Lhs{});
+    auto rhs = make_runtime_conditional(Cond{}, Rhs{});
+
+    using lhs_t = decltype(lhs);
+    using rhs_t = decltype(rhs);
+
+    return flow::dsl::par<lhs_t, rhs_t, Identity>{lhs, rhs};
+}
diff --git a/include/flow/detail/seq.hpp b/include/flow/detail/seq.hpp
index 0b481aa8..6494d280 100644
--- a/include/flow/detail/seq.hpp
+++ b/include/flow/detail/seq.hpp
@@ -1,15 +1,24 @@
 #pragma once
 
+#include <cib/detail/runtime_conditional.hpp>
 #include <flow/detail/walk.hpp>
+#include <flow/subgraph_identity.hpp>
 
 #include <stdx/tuple_algorithms.hpp>
 
 namespace flow::dsl {
-template <node Lhs, node Rhs> struct seq {
+template <subgraph Lhs, subgraph Rhs,
+          subgraph_identity Identity = subgraph_identity::REFERENCE,
+          typename Cond = cib::detail::always_condition_t>
+struct seq {
     Lhs lhs;
     Rhs rhs;
 
-    using is_node = void;
+    using is_subgraph = void;
+
+    constexpr auto operator*() const {
+        return seq<Lhs, Rhs, subgraph_identity::VALUE, Cond>{Lhs{}, Rhs{}};
+    }
 
   private:
     friend constexpr auto tag_invoke(get_initials_t, seq const &s) {
@@ -21,7 +30,21 @@ template <node Lhs, node Rhs> struct seq {
     }
 
     friend constexpr auto tag_invoke(get_nodes_t, seq const &s) {
-        return stdx::tuple_cat(get_nodes(s.lhs), get_nodes(s.rhs));
+        if constexpr (Identity == subgraph_identity::VALUE) {
+            auto all_nodes = stdx::to_unsorted_set(
+                stdx::tuple_cat(get_all_mentioned_nodes(s.lhs),
+                                get_all_mentioned_nodes(s.rhs)));
+
+            return stdx::transform([](auto const &n) { return *n; }, all_nodes);
+
+        } else {
+            return stdx::tuple_cat(get_nodes(s.lhs), get_nodes(s.rhs));
+        }
+    }
+
+    friend constexpr auto tag_invoke(get_all_mentioned_nodes_t, seq const &s) {
+        return stdx::tuple_cat(get_all_mentioned_nodes(s.lhs),
+                               get_all_mentioned_nodes(s.rhs));
     }
 
     friend constexpr auto tag_invoke(get_edges_t, seq const &s) {
@@ -33,16 +56,31 @@ template <node Lhs, node Rhs> struct seq {
             transform(
                 []<typename P>(P const &) {
                     return edge<stdx::tuple_element_t<0, P>,
-                                stdx::tuple_element_t<1, P>>{};
+                                stdx::tuple_element_t<1, P>, Cond>{};
                 },
                 cartesian_product_copy(fs, is)));
     }
 };
 
-template <node Lhs, node Rhs> seq(Lhs, Rhs) -> seq<Lhs, Rhs>;
+template <subgraph Lhs, subgraph Rhs> seq(Lhs, Rhs) -> seq<Lhs, Rhs>;
+
 } // namespace flow::dsl
 
-template <flow::dsl::node Lhs, flow::dsl::node Rhs>
+template <flow::dsl::subgraph Lhs, flow::dsl::subgraph Rhs>
 [[nodiscard]] constexpr auto operator>>(Lhs const &lhs, Rhs const &rhs) {
     return flow::dsl::seq{lhs, rhs};
 }
+
+template <typename Cond, flow::dsl::subgraph Lhs, flow::dsl::subgraph Rhs,
+          flow::subgraph_identity Identity, typename EdgeCond>
+constexpr auto
+make_runtime_conditional(Cond, flow::dsl::seq<Lhs, Rhs, Identity, EdgeCond>) {
+    auto lhs = make_runtime_conditional(Cond{}, Lhs{});
+    auto rhs = make_runtime_conditional(Cond{}, Rhs{});
+
+    using lhs_t = decltype(lhs);
+    using rhs_t = decltype(rhs);
+    using cond_t = decltype(EdgeCond{} and Cond{});
+
+    return flow::dsl::seq<lhs_t, rhs_t, Identity, cond_t>{lhs, rhs};
+}
diff --git a/include/flow/detail/walk.hpp b/include/flow/detail/walk.hpp
index 2348b4b1..596158b8 100644
--- a/include/flow/detail/walk.hpp
+++ b/include/flow/detail/walk.hpp
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <flow/subgraph_identity.hpp>
+
 #include <stdx/concepts.hpp>
 #include <stdx/tuple.hpp>
 #include <stdx/type_traits.hpp>
@@ -8,15 +10,17 @@
 
 namespace flow::dsl {
 template <typename T>
-concept node = requires { typename stdx::remove_cvref_t<T>::is_node; };
+concept subgraph = requires { typename stdx::remove_cvref_t<T>::is_subgraph; };
 
-template <typename Source, typename Dest> struct edge {
+template <typename Source, typename Dest, typename Cond> struct edge {
     using source_t = Source;
     using dest_t = Dest;
+    using cond_t = Cond;
 };
 
 constexpr inline class get_initials_t {
-    template <node N> friend constexpr auto tag_invoke(get_initials_t, N &&n) {
+    template <subgraph N>
+    friend constexpr auto tag_invoke(get_initials_t, N &&n) {
         return stdx::make_tuple(std::forward<N>(n));
     }
 
@@ -31,7 +35,8 @@ constexpr inline class get_initials_t {
 } get_initials{};
 
 constexpr inline class get_finals_t {
-    template <node N> friend constexpr auto tag_invoke(get_finals_t, N &&n) {
+    template <subgraph N>
+    friend constexpr auto tag_invoke(get_finals_t, N &&n) {
         return stdx::make_tuple(std::forward<N>(n));
     }
 
@@ -46,8 +51,13 @@ constexpr inline class get_finals_t {
 } get_finals{};
 
 constexpr inline class get_nodes_t {
-    template <node N> friend constexpr auto tag_invoke(get_nodes_t, N &&n) {
-        return stdx::make_tuple(std::forward<N>(n));
+    template <subgraph N> friend constexpr auto tag_invoke(get_nodes_t, N &&n) {
+        if constexpr (std::remove_cvref_t<N>::identity ==
+                      subgraph_identity::REFERENCE) {
+            return stdx::tuple{};
+        } else {
+            return stdx::make_tuple(std::forward<N>(n));
+        }
     }
 
   public:
@@ -60,8 +70,24 @@ constexpr inline class get_nodes_t {
     }
 } get_nodes{};
 
+constexpr inline class get_all_mentioned_nodes_t {
+    template <subgraph N>
+    friend constexpr auto tag_invoke(get_all_mentioned_nodes_t, N &&n) {
+        return stdx::make_tuple(std::forward<N>(n));
+    }
+
+  public:
+    template <typename... Ts>
+    constexpr auto operator()(Ts &&...ts) const
+        noexcept(noexcept(tag_invoke(std::declval<get_all_mentioned_nodes_t>(),
+                                     std::forward<Ts>(ts)...)))
+            -> decltype(tag_invoke(*this, std::forward<Ts>(ts)...)) {
+        return tag_invoke(*this, std::forward<Ts>(ts)...);
+    }
+} get_all_mentioned_nodes{};
+
 constexpr inline class get_edges_t {
-    friend constexpr auto tag_invoke(get_edges_t, node auto const &) {
+    friend constexpr auto tag_invoke(get_edges_t, subgraph auto const &) {
         return stdx::tuple{};
     }
 
diff --git a/include/flow/graph_builder.hpp b/include/flow/graph_builder.hpp
index 7bde6491..22fadadf 100644
--- a/include/flow/graph_builder.hpp
+++ b/include/flow/graph_builder.hpp
@@ -4,12 +4,16 @@
 #include <flow/detail/walk.hpp>
 #include <flow/impl.hpp>
 
+#include <stdx/ct_format.hpp>
 #include <stdx/ct_string.hpp>
 #include <stdx/cx_multimap.hpp>
 #include <stdx/cx_set.hpp>
 #include <stdx/cx_vector.hpp>
 #include <stdx/tuple_algorithms.hpp>
 #include <stdx/type_traits.hpp>
+#include <stdx/utility.hpp>
+
+#include <boost/mp11/set.hpp>
 
 #include <algorithm>
 #include <array>
@@ -20,14 +24,21 @@
 #include <utility>
 
 namespace flow {
+namespace detail {
+template <typename T> using is_duplicated = std::bool_constant<(T::size() > 1)>;
+}
+template <typename T> using name_for = typename T::name_t;
+
 [[nodiscard]] constexpr auto edge_size(auto const &nodes,
                                        auto const &edges) -> std::size_t {
     auto const edge_capacities = transform(
         [&]<typename N>(N const &) {
             return edges.fold_left(
                 std::size_t{}, []<typename E>(auto acc, E const &) {
-                    if constexpr (std::is_same_v<typename E::source_t, N> or
-                                  std::is_same_v<typename E::dest_t, N>) {
+                    if constexpr (std::is_same_v<name_for<typename E::source_t>,
+                                                 name_for<N>> or
+                                  std::is_same_v<name_for<typename E::dest_t>,
+                                                 name_for<N>>) {
                         return ++acc;
                     } else {
                         return acc;
@@ -41,10 +52,31 @@ namespace flow {
     });
 }
 
-template <template <stdx::ct_string, std::size_t> typename Impl>
-struct graph_builder {
-    template <typename T> using name_for = typename T::name_t;
+template <typename Cond> struct sequence_conditions;
+
+template <auto...> struct INFO_flow_name_;
+
+template <auto...> struct INFO_step_a_name_;
+
+template <auto...> struct INFO_step_a_condition_;
+
+template <auto...> struct INFO_step_b_name_;
+
+template <auto...> struct INFO_step_b_condition_;
+
+template <auto...> struct INFO_sequence_condition_;
 
+template <typename...> struct INFO_sequence_missing_predicate_;
+
+template <typename...> constexpr bool ERROR_DETAILS_ = false;
+
+template <auto...> struct INFO_missing_steps_;
+
+template <auto...> struct INFO_duplicated_steps_;
+
+template <stdx::ct_string Name,
+          template <stdx::ct_string, std::size_t> typename Impl>
+struct graph_builder {
     template <typename Node, std::size_t N, std::size_t E>
     [[nodiscard]] constexpr static auto make_graph(auto const &nodes,
                                                    auto const &edges) {
@@ -54,9 +86,49 @@ struct graph_builder {
 
         auto const named_nodes = stdx::apply_indices<name_for>(nodes);
         for_each(
-            [&]<typename Edge>(Edge const &) {
-                g.put(get<name_for<typename Edge::source_t>>(named_nodes),
-                      get<name_for<typename Edge::dest_t>>(named_nodes));
+            [&]<typename Lhs, typename Rhs, typename Cond>(
+                dsl::edge<Lhs, Rhs, Cond> const &) {
+                auto lhs = get<name_for<Lhs>>(named_nodes);
+                auto rhs = get<name_for<Rhs>>(named_nodes);
+
+                using lhs_t = std::remove_cvref_t<decltype(lhs)>;
+                using rhs_t = std::remove_cvref_t<decltype(rhs)>;
+
+                using edge_ps_t = decltype(Cond::predicates);
+                auto node_ps = stdx::to_unsorted_set(stdx::tuple_cat(
+                    lhs_t::condition.predicates, rhs_t::condition.predicates));
+
+                stdx::for_each(
+                    [&]<typename P>(P const &) {
+                        if constexpr (not stdx::contains_type<edge_ps_t, P>) {
+                            static_assert(
+                                ERROR_DETAILS_<
+                                    INFO_flow_name_<Name>,
+                                    INFO_step_a_name_<lhs_t::ct_name>,
+                                    INFO_step_a_condition_<
+                                        lhs_t::condition.ct_name>,
+                                    INFO_step_b_name_<rhs_t::ct_name>,
+                                    INFO_step_b_condition_<
+                                        rhs_t::condition.ct_name>,
+                                    INFO_sequence_condition_<Cond::ct_name>,
+                                    INFO_sequence_missing_predicate_<P>>,
+
+                                "The conditions on this sequence "
+                                "(step_a >> step_b) are weaker than those on "
+                                "step_a and/or step_b. The sequence could be "
+                                "enabled while step_a and/or step_b is not. "
+                                "Specifically, the sequence is missing the "
+                                "predicate identified in "
+                                "`INFO_sequence_missing_predicate_`. TIP: "
+                                "Look for 'ERROR_DETAILS_` and `INFO_` in "
+                                "the compiler error message for details on "
+                                "the sequence, the step names, and the "
+                                "conditions.");
+                        }
+                    },
+                    node_ps);
+
+                g.put(lhs, rhs);
             },
             edges);
         return g;
@@ -119,13 +191,76 @@ struct graph_builder {
             std::span{std::cbegin(ordered_list), std::size(ordered_list)}};
     }
 
+    constexpr static void check_for_missing_nodes(auto nodes,
+                                                  auto mentioned_nodes) {
+        constexpr auto get_name = []<typename N>(N) ->
+            typename N::name_t { return {}; };
+        auto node_names = stdx::transform(get_name, nodes);
+        auto mentioned_node_names = stdx::transform(get_name, mentioned_nodes);
+
+        using node_names_t = decltype(stdx::to_sorted_set(node_names));
+        using mentioned_node_names_t =
+            decltype(stdx::to_sorted_set(mentioned_node_names));
+
+        if constexpr (not std::is_same_v<node_names_t,
+                                         mentioned_node_names_t>) {
+            using missing_nodes_t =
+                boost::mp11::mp_set_difference<mentioned_node_names_t,
+                                               node_names_t>;
+
+            constexpr auto missing_nodes = missing_nodes_t{};
+            constexpr auto missing_nodes_ct_strings = stdx::transform(
+                []<typename N>(N) { return stdx::ct_string_from_type(N{}); },
+                missing_nodes);
+
+            [&]<std::size_t... Is>(std::index_sequence<Is...>) {
+                using error_details_t = INFO_missing_steps_<stdx::get<Is>(
+                    missing_nodes_ct_strings)...>;
+
+                static_assert(
+                    ERROR_DETAILS_<INFO_flow_name_<Name>, error_details_t>,
+                    "One or more steps are referenced in the flow but not "
+                    "explicitly added with the * operator. The "
+                    "beginning of this error shows you which steps are "
+                    "missing.");
+            }(std::make_index_sequence<
+                stdx::tuple_size_v<decltype(missing_nodes)>>{});
+        }
+
+        if constexpr (stdx::tuple_size_v<node_names_t> !=
+                      stdx::tuple_size_v<decltype(node_names)>) {
+            constexpr auto duplicates = stdx::transform(
+                [](auto e) {
+                    return stdx::ct_string_from_type(stdx::get<0>(e));
+                },
+                stdx::filter<detail::is_duplicated>(stdx::gather(node_names)));
+
+            [&]<std::size_t... Is>(std::index_sequence<Is...>) {
+                using error_details_t =
+                    INFO_duplicated_steps_<stdx::get<Is>(duplicates)...>;
+
+                static_assert(
+                    ERROR_DETAILS_<INFO_flow_name_<Name>, error_details_t>,
+                    "One or more steps are explicitly added more than once "
+                    "using the * operator. The beginning of this "
+                    "error shows you which steps are duplicated.");
+            }(std::make_index_sequence<
+                stdx::tuple_size_v<decltype(duplicates)>>{});
+        }
+    }
+
     template <typename Graph>
     [[nodiscard]] constexpr static auto build(Graph const &input) {
         auto nodes = flow::dsl::get_nodes(input);
-        auto edges = flow::dsl::get_edges(input);
+        auto mentioned_nodes = flow::dsl::get_all_mentioned_nodes(input);
+
+        check_for_missing_nodes(nodes, mentioned_nodes);
 
-        constexpr auto node_capacity = stdx::tuple_size_v<decltype(nodes)>;
-        constexpr auto edge_capacity = edge_size(nodes, edges);
+        auto node_set = stdx::to_unsorted_set(nodes);
+        auto edges = stdx::to_unsorted_set(flow::dsl::get_edges(input));
+
+        constexpr auto node_capacity = stdx::tuple_size_v<decltype(node_set)>;
+        constexpr auto edge_capacity = edge_size(node_set, edges);
 
         using output_t = Impl<Graph::name, node_capacity>;
         using rt_node_t = typename output_t::node_t;
@@ -135,11 +270,11 @@ struct graph_builder {
                 []<typename N>(N const &) {
                     return std::is_convertible_v<N, rt_node_t>;
                 },
-                nodes),
+                node_set),
             "Output node type is not compatible with given input nodes");
 
-        auto g =
-            make_graph<rt_node_t, node_capacity, edge_capacity>(nodes, edges);
+        auto g = make_graph<rt_node_t, node_capacity, edge_capacity>(node_set,
+                                                                     edges);
         return topo_sort<output_t>(g);
     }
 
@@ -173,25 +308,19 @@ struct graph_builder {
     }
 };
 
-template <stdx::ct_string Name = "", typename Renderer = graph_builder<impl>,
-          flow::dsl::node... Fragments>
+template <stdx::ct_string Name = "",
+          typename Renderer = graph_builder<Name, impl>,
+          flow::dsl::subgraph... Fragments>
 class graph {
-    friend constexpr auto tag_invoke(flow::dsl::get_nodes_t, graph const &g) {
-        auto t = g.fragments.apply([](auto const &...frags) {
-            return stdx::tuple_cat(flow::dsl::get_nodes(frags)...);
-        });
-        return stdx::to_unsorted_set(t);
-    }
-
-    friend constexpr auto tag_invoke(flow::dsl::get_edges_t, graph const &g) {
-        auto t = g.fragments.apply([](auto const &...frags) {
-            return stdx::tuple_cat(flow::dsl::get_edges(frags)...);
+    template <typename Tag>
+    friend constexpr auto tag_invoke(Tag, graph const &g) {
+        return g.fragments.apply([](auto const &...frags) {
+            return stdx::tuple_cat(Tag{}(frags)...);
         });
-        return stdx::to_unsorted_set(t);
     }
 
   public:
-    template <flow::dsl::node... Ns>
+    template <flow::dsl::subgraph... Ns>
     [[nodiscard]] constexpr auto add(Ns &&...ns) {
         return fragments.apply([&](auto &...frags) {
             return graph<Name, Renderer, Fragments...,
diff --git a/include/flow/step.hpp b/include/flow/step.hpp
index 56483beb..d4e9dbf8 100644
--- a/include/flow/step.hpp
+++ b/include/flow/step.hpp
@@ -1,7 +1,9 @@
 #pragma once
 
+#include <cib/detail/runtime_conditional.hpp>
 #include <cib/func_decl.hpp>
 #include <flow/common.hpp>
+#include <flow/subgraph_identity.hpp>
 #include <log/log.hpp>
 #include <sc/string_constant.hpp>
 
@@ -21,23 +23,50 @@ struct rt_node {
                                      rt_node const &) -> bool = default;
 };
 
-template <stdx::ct_string Name> struct ct_node : rt_node {
-    using is_node = void;
+template <stdx::ct_string Type, stdx::ct_string Name,
+          subgraph_identity Identity, typename Cond, typename F>
+struct ct_node : rt_node {
+    using is_subgraph = void;
+    using type_t =
+        decltype(stdx::ct_string_to_type<Type, sc::string_constant>());
+
     using name_t =
         decltype(stdx::ct_string_to_type<Name, sc::string_constant>());
-};
 
-template <stdx::ct_string Name, stdx::ct_string Type>
-static void log_name_func() {
-    CIB_TRACE("flow.{}({})",
-              stdx::ct_string_to_type<Type, sc::string_constant>(),
-              stdx::ct_string_to_type<Name, sc::string_constant>());
-}
+    constexpr static auto ct_name = Name;
+
+    constexpr static auto identity = Identity;
+
+    constexpr static auto condition = Cond{};
+
+    constexpr static auto run_func = [] {
+        if (condition) {
+            F{}();
+        }
+    };
+
+    constexpr static auto log_func = [] {
+        if (condition) {
+            CIB_TRACE("flow.{}({})", type_t{}, name_t{});
+        }
+    };
+
+    constexpr ct_node() : rt_node{run_func, log_func} {}
+
+    constexpr auto operator*() const {
+        if constexpr (Identity == subgraph_identity::REFERENCE) {
+            return ct_node<Type, Name, subgraph_identity::VALUE, Cond, F>{};
+        } else {
+            return ct_node{};
+        }
+    }
+};
 
 namespace detail {
-template <stdx::ct_string Name, stdx::ct_string Type, typename F>
+template <stdx::ct_string Type, stdx::ct_string Name, typename F>
 [[nodiscard]] constexpr auto make_node() {
-    return ct_node<Name>{{.run = F{}, .log_name = log_name_func<Name, Type>}};
+    return ct_node<Type, Name, subgraph_identity::REFERENCE,
+                   cib::detail::always_condition_t, F>{};
 }
 
 constexpr auto empty_func = []() {};
@@ -46,7 +75,7 @@ constexpr auto empty_func = []() {};
 template <stdx::ct_string Name, typename F>
     requires(stdx::is_function_object_v<F> and std::is_empty_v<F>)
 [[nodiscard]] constexpr auto action(F const &) {
-    return detail::make_node<Name, "action", F>();
+    return detail::make_node<"action", Name, F>();
 }
 
 template <stdx::ct_string Name> [[nodiscard]] constexpr auto action() {
@@ -58,7 +87,7 @@ template <stdx::ct_string Name> [[nodiscard]] constexpr auto step() {
 }
 
 template <stdx::ct_string Name> [[nodiscard]] constexpr auto milestone() {
-    return detail::make_node<Name, "milestone", decltype(detail::empty_func)>();
+    return detail::make_node<"milestone", Name, decltype(detail::empty_func)>();
 }
 
 inline namespace literals {
@@ -75,4 +104,17 @@ template <stdx::ct_string S>
     return milestone<S>();
 }
 } // namespace literals
+
+template <typename Cond, stdx::ct_string Type, stdx::ct_string Name,
+          subgraph_identity Identity, typename NodeCond, typename F>
+constexpr auto
+make_runtime_conditional(Cond, ct_node<Type, Name, Identity, NodeCond, F>) {
+    if constexpr (Identity == subgraph_identity::VALUE) {
+        return ct_node<Type, Name, Identity, decltype(NodeCond{} and Cond{}),
+                       F>{};
+    } else {
+        return ct_node<Type, Name, Identity, NodeCond, F>{};
+    }
+}
+
 } // namespace flow
diff --git a/include/flow/subgraph_identity.hpp b/include/flow/subgraph_identity.hpp
new file mode 100644
index 00000000..cf974aa9
--- /dev/null
+++ b/include/flow/subgraph_identity.hpp
@@ -0,0 +1,5 @@
+#pragma once
+
+namespace flow {
+enum class subgraph_identity { VALUE, REFERENCE };
+}
diff --git a/include/match/predicate.hpp b/include/match/predicate.hpp
index 2b332336..7b02264a 100644
--- a/include/match/predicate.hpp
+++ b/include/match/predicate.hpp
@@ -12,7 +12,12 @@
 namespace match {
 template <stdx::ct_string Name, stdx::callable P> struct predicate_t {
     using is_matcher = void;
-    [[no_unique_address]] P pred;
+
+    constexpr static P pred{};
+
+    constexpr predicate_t(P) {}
+
+    constexpr predicate_t() {}
 
     [[nodiscard]] constexpr auto
     operator()(auto const &event) const -> decltype(pred(event)) {
diff --git a/include/msg/callback.hpp b/include/msg/callback.hpp
index 4074cf57..46d6e293 100644
--- a/include/msg/callback.hpp
+++ b/include/msg/callback.hpp
@@ -2,6 +2,7 @@
 
 #include <log/log.hpp>
 #include <match/ops.hpp>
+#include <match/predicate.hpp>
 #include <msg/message.hpp>
 
 #include <stdx/concepts.hpp>
@@ -84,6 +85,24 @@ template <stdx::ct_string Name, typename Msg> struct callback_construct_t {
         using fn = std::is_same<N, typename Field::name_t>;
     };
 };
+
+template <typename Cond, stdx::ct_string Name, typename Msg, match::matcher M,
+          stdx::callable F>
+constexpr auto make_runtime_conditional(Cond, callback<Name, Msg, M, F> cb) {
+    using ::operator and;
+
+    auto predicate = match::predicate<Cond::ct_name>(
+        [](auto...) -> bool { return static_cast<bool>(Cond{}); });
+    using predicate_t = decltype(predicate);
+
+    auto new_matcher = match::sum_of_products(M{} and predicate_t{});
+    using new_matcher_t = decltype(new_matcher);
+
+    using new_cb_t = callback<Name, Msg, new_matcher_t, F>;
+
+    return new_cb_t{new_matcher, cb.callable};
+}
+
 } // namespace detail
 
 template <stdx::ct_string Name, typename Msg>
diff --git a/include/seq/builder.hpp b/include/seq/builder.hpp
index a8ae6cd4..12879946 100644
--- a/include/seq/builder.hpp
+++ b/include/seq/builder.hpp
@@ -9,7 +9,7 @@
 
 namespace seq {
 template <stdx::ct_string Name = "">
-using builder = flow::graph<Name, flow::graph_builder<impl>>;
+using builder = flow::graph<Name, flow::graph_builder<Name, impl>>;
 
 template <stdx::ct_string Name = "">
 struct service : cib::builder_meta<builder<Name>, flow::FunctionPtr> {};
diff --git a/include/seq/step.hpp b/include/seq/step.hpp
index 9c0b8d90..478d4712 100644
--- a/include/seq/step.hpp
+++ b/include/seq/step.hpp
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <cib/detail/runtime_conditional.hpp>
+#include <flow/subgraph_identity.hpp>
 #include <log/log.hpp>
 #include <sc/string_constant.hpp>
 
@@ -12,7 +14,7 @@ using func_ptr = auto (*)() -> status;
 using log_func_ptr = auto (*)() -> void;
 
 struct rt_step {
-    using is_node = void;
+    using is_subgraph = void;
 
     func_ptr forward_ptr{};
     func_ptr backward_ptr{};
@@ -23,10 +25,21 @@ struct rt_step {
     operator==(rt_step const &, rt_step const &) -> bool = default;
 };
 
-template <stdx::ct_string Name> struct ct_step : rt_step {
-    using is_node = void;
+template <stdx::ct_string Name, bool IsReference = true>
+struct ct_step : rt_step {
+    using is_subgraph = void;
     using name_t =
         decltype(stdx::ct_string_to_type<Name, sc::string_constant>());
+
+    constexpr static auto identity = flow::subgraph_identity::VALUE;
+
+    constexpr static auto condition = cib::detail::always_condition;
+
+    constexpr static auto ct_name = Name;
+
+    constexpr auto operator*() const -> ct_step<Name, false> {
+        return {forward_ptr, backward_ptr, log_name};
+    }
 };
 
 /**
diff --git a/test/flow/fail/CMakeLists.txt b/test/flow/fail/CMakeLists.txt
index e43f6b1d..7c41db00 100644
--- a/test/flow/fail/CMakeLists.txt
+++ b/test/flow/fail/CMakeLists.txt
@@ -1 +1,5 @@
 add_compile_fail_test(cyclic_flow.cpp LIBRARIES warnings cib)
+add_compile_fail_test(only_reference_added.cpp LIBRARIES warnings cib)
+add_compile_fail_test(mismatched_flow_runtime_conditional.cpp LIBRARIES
+                      warnings cib)
+add_compile_fail_test(node_explicitly_added_twice.cpp LIBRARIES warnings cib)
diff --git a/test/flow/fail/cyclic_flow.cpp b/test/flow/fail/cyclic_flow.cpp
index c0810291..0c03b3ba 100644
--- a/test/flow/fail/cyclic_flow.cpp
+++ b/test/flow/fail/cyclic_flow.cpp
@@ -13,7 +13,7 @@ struct TestFlowAlpha : public flow::service<> {};
 
 struct CyclicFlowConfig {
     constexpr static auto config = cib::config(
-        cib::exports<TestFlowAlpha>, cib::extend<TestFlowAlpha>(a >> b >> a));
+        cib::exports<TestFlowAlpha>, cib::extend<TestFlowAlpha>(*a >> *b >> a));
 };
 } // namespace
 
diff --git a/test/flow/fail/mismatched_flow_runtime_conditional.cpp b/test/flow/fail/mismatched_flow_runtime_conditional.cpp
new file mode 100644
index 00000000..32c16854
--- /dev/null
+++ b/test/flow/fail/mismatched_flow_runtime_conditional.cpp
@@ -0,0 +1,28 @@
+#include <cib/cib.hpp>
+#include <flow/flow.hpp>
+
+// EXPECT: The conditions on this sequence
+
+namespace {
+using namespace flow::literals;
+
+constexpr auto a = flow::milestone<"a">();
+constexpr auto b = flow::milestone<"b">();
+
+struct TestFlowAlpha : public flow::service<> {};
+
+constexpr auto when_feature_a_enabled =
+    cib::runtime_condition<"feature_a_enabled">([] { return true; });
+
+struct FlowConfig {
+    constexpr static auto config =
+        cib::config(cib::exports<TestFlowAlpha>,
+                    when_feature_a_enabled(cib::extend<TestFlowAlpha>(*a)),
+                    cib::extend<TestFlowAlpha>(a >> *b));
+};
+} // namespace
+
+auto main() -> int {
+    cib::nexus<FlowConfig> nexus{};
+    nexus.service<TestFlowAlpha>();
+}
diff --git a/test/flow/fail/node_explicitly_added_twice.cpp b/test/flow/fail/node_explicitly_added_twice.cpp
new file mode 100644
index 00000000..ba99bb4f
--- /dev/null
+++ b/test/flow/fail/node_explicitly_added_twice.cpp
@@ -0,0 +1,22 @@
+#include <cib/cib.hpp>
+#include <flow/flow.hpp>
+
+// EXPECT: One or more steps are explicitly added more than once
+
+namespace {
+using namespace flow::literals;
+
+constexpr auto a = flow::milestone<"a">();
+
+struct TestFlowAlpha : public flow::service<> {};
+
+struct FlowConfig {
+    constexpr static auto config = cib::config(
+        cib::exports<TestFlowAlpha>, cib::extend<TestFlowAlpha>(*a, *a));
+};
+} // namespace
+
+auto main() -> int {
+    cib::nexus<FlowConfig> nexus{};
+    nexus.service<TestFlowAlpha>();
+}
diff --git a/test/flow/fail/only_reference_added.cpp b/test/flow/fail/only_reference_added.cpp
new file mode 100644
index 00000000..44130097
--- /dev/null
+++ b/test/flow/fail/only_reference_added.cpp
@@ -0,0 +1,22 @@
+#include <cib/cib.hpp>
+#include <flow/flow.hpp>
+
+// EXPECT: One or more steps are referenced in the flow but not explicitly
+
+namespace {
+using namespace flow::literals;
+
+constexpr auto a = flow::milestone<"a">();
+
+struct TestFlowAlpha : public flow::service<> {};
+
+struct FlowConfig {
+    constexpr static auto config =
+        cib::config(cib::exports<TestFlowAlpha>, cib::extend<TestFlowAlpha>(a));
+};
+} // namespace
+
+auto main() -> int {
+    cib::nexus<FlowConfig> nexus{};
+    nexus.service<TestFlowAlpha>();
+}
diff --git a/test/flow/flow.cpp b/test/flow/flow.cpp
index 818f9794..1edfe1d2 100644
--- a/test/flow/flow.cpp
+++ b/test/flow/flow.cpp
@@ -14,6 +14,8 @@ std::string actual = {};
 namespace {
 using namespace flow::literals;
 
+std::string log_buffer{};
+
 constexpr auto a = flow::action<"a">([] { actual += "a"; });
 constexpr auto b = flow::action<"b">([] { actual += "b"; });
 constexpr auto c = flow::action<"c">([] { actual += "c"; });
@@ -22,92 +24,188 @@ constexpr auto d = flow::action<"d">([] { actual += "d"; });
 struct TestFlowAlpha : public flow::service<> {};
 struct TestFlowBeta : public flow::service<> {};
 
-struct SingleFlowEmptyConfig {
-    constexpr static auto config = cib::config(cib::exports<TestFlowAlpha>);
+template <auto... Cs> struct wrapper {
+    struct inner {
+        constexpr static auto config = cib::config(Cs...);
+    };
+    constexpr static auto n = cib::nexus<inner>{};
+
+    wrapper() { n.init(); }
+
+    template <typename S> static auto run() -> void { n.template service<S>(); }
+};
+
+template <typename S, auto... Cs>
+constexpr auto check_flow = [](std::string_view expected) -> void {
+    actual.clear();
+    log_buffer.clear();
+    wrapper<Cs...>::template run<S>();
+    CHECK(actual == expected);
 };
 } // namespace
 
+template <bool V>
+constexpr auto when = cib::runtime_condition<"when">([] { return V; });
+
 TEST_CASE("run empty flow through cib::nexus", "[flow]") {
-    actual.clear();
-    cib::nexus<SingleFlowEmptyConfig> nexus{};
-    nexus.service<TestFlowAlpha>();
-    CHECK(std::empty(actual));
+    check_flow<TestFlowAlpha, cib::exports<TestFlowAlpha>>("");
 }
 
 namespace {
-struct SingleFlowSingleActionConfig {
+template <stdx::ct_string Name = "">
+using alt_builder = flow::graph<Name, flow::graphviz_builder>;
+template <stdx::ct_string Name = "">
+struct alt_flow_service
+    : cib::builder_meta<alt_builder<Name>, flow::VizFunctionPtr> {};
+
+struct VizFlow : public alt_flow_service<"debug"> {};
+struct VizConfig {
     constexpr static auto config =
-        cib::config(cib::exports<TestFlowAlpha>, cib::extend<TestFlowAlpha>(a));
+        cib::config(cib::exports<VizFlow>, cib::extend<VizFlow>(*a));
 };
 } // namespace
 
+TEST_CASE("vizualize flow", "[flow]") {
+    cib::nexus<VizConfig> nexus{};
+    auto viz = nexus.service<VizFlow>();
+    auto expected = std::string{
+        R"__debug__(digraph debug {
+start -> a
+a -> end
+})__debug__"};
+    CHECK(viz == expected);
+}
+
+#if defined(__GNUC__) && __GNUC__ == 12
+#else
+
 TEST_CASE("add single action through cib::nexus", "[flow]") {
+    check_flow<TestFlowAlpha, cib::exports<TestFlowAlpha>,
+               cib::extend<TestFlowAlpha>(*a)>("a");
+}
+
+TEST_CASE("add runtime conditional action through cib::nexus", "[flow]") {
+    check_flow<TestFlowAlpha, cib::exports<TestFlowAlpha>,
+               when<true>(cib::extend<TestFlowAlpha>(*a))>("a");
+
+    check_flow<TestFlowAlpha, cib::exports<TestFlowAlpha>,
+               when<false>(cib::extend<TestFlowAlpha>(*a))>("");
+}
+
+TEST_CASE("add multi-level runtime conditional action through cib::nexus",
+          "[flow]") {
+    auto check = []<bool level0, bool level1>(auto expected) {
+        check_flow<TestFlowAlpha, cib::exports<TestFlowAlpha>,
+                   when<level0>(when<level1>(cib::extend<TestFlowAlpha>(*a)))>(
+            expected);
+    };
+
+    check.operator()<true, true>("a");
+    check.operator()<true, false>("");
+    check.operator()<false, true>("");
+    check.operator()<false, false>("");
+}
+
+TEST_CASE("dependencies between runtime conditional actions through cib::nexus",
+          "[flow]") {
+    auto check = []<bool ca, bool cb>(auto expected) {
+        check_flow<TestFlowAlpha, cib::exports<TestFlowAlpha>,
+                   when<ca>(cib::extend<TestFlowAlpha>(*a)),
+                   when<cb>(cib::extend<TestFlowAlpha>(*b)),
+                   (when<ca> and when<cb>)(cib::extend<TestFlowAlpha>(a >> b))>(
+            expected);
+    };
+
+    check.operator()<true, true>("ab");
+    check.operator()<true, false>("a");
+    check.operator()<false, true>("b");
+    check.operator()<false, false>("");
+}
+
+TEST_CASE("dependency conditions imply action conditions", "[flow]") {
+    auto check = []<bool ca, bool cb, bool cc>(auto expected) {
+        check_flow<TestFlowAlpha, cib::exports<TestFlowAlpha>,
+                   when<ca>(cib::extend<TestFlowAlpha>(*a)),
+                   when<cb>(cib::extend<TestFlowAlpha>(*b)),
+                   (when<ca> and when<cb> and
+                    when<cc>)(cib::extend<TestFlowAlpha>(a >> b))>(expected);
+    };
+
+    check.operator()<true, true, true>("ab");
+    check.operator()<true, false, true>("a");
+    check.operator()<true, false, false>("a");
+    check.operator()<false, true, true>("b");
+    check.operator()<false, true, false>("b");
+    check.operator()<false, false, false>("");
+}
+
+TEST_CASE("dependencies between runtime conditional and always actions through "
+          "cib::nexus",
+          "[flow]") {
+    auto check = []<bool ca, bool cb>(auto expected) {
+        check_flow<TestFlowAlpha, cib::exports<TestFlowAlpha>,
+                   when<ca>(cib::extend<TestFlowAlpha>(*a >> c)),
+                   when<cb>(cib::extend<TestFlowAlpha>(c >> *b)),
+                   cib::extend<TestFlowAlpha>(*c)>(expected);
+    };
+
+    check.operator()<true, true>("acb");
+    check.operator()<true, false>("ac");
+    check.operator()<false, true>("cb");
+    check.operator()<false, false>("c");
+}
+
+TEST_CASE("add par runtime conditional (true) actions through cib::nexus",
+          "[flow]") {
     actual.clear();
-    cib::nexus<SingleFlowSingleActionConfig> nexus{};
-    nexus.service<TestFlowAlpha>();
-    CHECK(actual == "a");
+
+    auto n0 = wrapper<cib::exports<TestFlowAlpha>,
+                      when<true>(cib::extend<TestFlowAlpha>(*a && *b))>{};
+
+    n0.run<TestFlowAlpha>();
+
+    CHECK(actual.find('a') != std::string::npos);
+    CHECK(actual.find('b') != std::string::npos);
 }
 
-namespace {
-struct MultiFlowMultiActionConfig {
-    constexpr static auto config = cib::config(
-        cib::exports<TestFlowAlpha, TestFlowBeta>,
-        cib::extend<TestFlowAlpha>(a >> b), cib::extend<TestFlowBeta>(c >> d));
-};
-} // namespace
+TEST_CASE("add par runtime conditional (false) actions through cib::nexus",
+          "[flow]") {
+    check_flow<TestFlowAlpha, cib::exports<TestFlowAlpha>,
+               when<false>(cib::extend<TestFlowAlpha>(*a && *b))>("");
+}
 
 TEST_CASE("add multi action through cib::nexus", "[flow]") {
     actual.clear();
-    cib::nexus<MultiFlowMultiActionConfig> nexus{};
-    nexus.service<TestFlowAlpha>();
-    nexus.service<TestFlowBeta>();
+
+    auto n = wrapper<cib::exports<TestFlowAlpha, TestFlowBeta>,
+                     cib::extend<TestFlowAlpha>(*a >> *b),
+                     cib::extend<TestFlowBeta>(*c >> *d)>{};
+
+    n.run<TestFlowAlpha>();
+    n.run<TestFlowBeta>();
     CHECK(actual == "abcd");
 }
 
 TEST_CASE("add multi action through cib::nexus, run through cib::service",
           "[flow]") {
     actual.clear();
-    cib::nexus<MultiFlowMultiActionConfig> nexus{};
-    nexus.init();
+
+    wrapper<cib::exports<TestFlowAlpha, TestFlowBeta>,
+            cib::extend<TestFlowAlpha>(*a >> *b),
+            cib::extend<TestFlowBeta>(*c >> *d)>{};
+
     cib::service<TestFlowAlpha>();
     cib::service<TestFlowBeta>();
     CHECK(actual == "abcd");
 }
 
-namespace {
-struct FlowFuncDeclConfig {
-    constexpr static auto config =
-        cib::config(cib::exports<TestFlowAlpha>,
-                    cib::extend<TestFlowAlpha>("e"_action >> "f"_action));
-};
-} // namespace
-
 TEST_CASE("add actions using func_decl through cib::nexus", "[flow]") {
-    actual.clear();
-    cib::nexus<FlowFuncDeclConfig> nexus{};
-    nexus.service<TestFlowAlpha>();
-    CHECK(actual == "ef");
+    check_flow<TestFlowAlpha, cib::exports<TestFlowAlpha>,
+               cib::extend<TestFlowAlpha>(*"e"_action >> *"f"_action)>("ef");
 }
 
 namespace {
 struct NamedTestFlow : public flow::service<"TestFlow"> {};
-
-struct EmptyNamedFlowConfig {
-    constexpr static auto config = cib::config(cib::exports<NamedTestFlow>);
-};
-
-struct NamedFlowConfig {
-    constexpr static auto config =
-        cib::config(cib::exports<NamedTestFlow>, cib::extend<NamedTestFlow>(a));
-};
-
-struct MSNamedFlowConfig {
-    constexpr static auto config =
-        cib::config(cib::exports<NamedTestFlow>,
-                    cib::extend<NamedTestFlow>("ms"_milestone));
-};
-
-std::string log_buffer{};
 } // namespace
 
 template <>
@@ -115,62 +213,37 @@ inline auto logging::config<> =
     logging::fmt::config{std::back_inserter(log_buffer)};
 
 TEST_CASE("unnamed flow does not log start/end", "[flow]") {
-    log_buffer.clear();
-    cib::nexus<SingleFlowEmptyConfig> nexus{};
-    nexus.service<TestFlowAlpha>();
+    check_flow<TestFlowAlpha, cib::exports<TestFlowAlpha>>("");
+
     CHECK(std::empty(log_buffer));
 }
 
 TEST_CASE("empty flow logs start/end", "[flow]") {
-    log_buffer.clear();
-    cib::nexus<EmptyNamedFlowConfig> nexus{};
-    nexus.service<NamedTestFlow>();
+    check_flow<NamedTestFlow, cib::exports<NamedTestFlow>>("");
+
     CHECK(log_buffer.find("flow.start(TestFlow)") != std::string::npos);
     CHECK(log_buffer.find("flow.end(TestFlow)") != std::string::npos);
 }
 
 TEST_CASE("unnamed flow does not log actions", "[flow]") {
-    log_buffer.clear();
-    cib::nexus<SingleFlowSingleActionConfig> nexus{};
-    nexus.service<TestFlowAlpha>();
+    check_flow<TestFlowAlpha, cib::exports<TestFlowAlpha>,
+               cib::extend<TestFlowAlpha>(*a)>("a");
+
     CHECK(log_buffer.find("flow.action(a)") == std::string::npos);
 }
 
 TEST_CASE("named flow logs actions", "[flow]") {
-    log_buffer.clear();
-    cib::nexus<NamedFlowConfig> nexus{};
-    nexus.service<NamedTestFlow>();
+    check_flow<NamedTestFlow, cib::exports<NamedTestFlow>,
+               cib::extend<NamedTestFlow>(*a)>("a");
+
     CHECK(log_buffer.find("flow.action(a)") != std::string::npos);
 }
 
 TEST_CASE("named flow logs milestones", "[flow]") {
-    log_buffer.clear();
-    cib::nexus<MSNamedFlowConfig> nexus{};
-    nexus.service<NamedTestFlow>();
+    check_flow<NamedTestFlow, cib::exports<NamedTestFlow>,
+               cib::extend<NamedTestFlow>(*"ms"_milestone)>("");
+
     CHECK(log_buffer.find("flow.milestone(ms)") != std::string::npos);
 }
 
-namespace {
-template <stdx::ct_string Name = "">
-using alt_builder = flow::graph<Name, flow::graphviz_builder>;
-template <stdx::ct_string Name = "">
-struct alt_flow_service
-    : cib::builder_meta<alt_builder<Name>, flow::VizFunctionPtr> {};
-
-struct VizFlow : public alt_flow_service<"debug"> {};
-struct VizConfig {
-    constexpr static auto config =
-        cib::config(cib::exports<VizFlow>, cib::extend<VizFlow>(a));
-};
-} // namespace
-
-TEST_CASE("vizualize flow", "[flow]") {
-    cib::nexus<VizConfig> nexus{};
-    auto viz = nexus.service<VizFlow>();
-    auto expected = std::string{
-        R"__debug__(digraph debug {
-start -> a
-a -> end
-})__debug__"};
-    CHECK(viz == expected);
-}
+#endif
diff --git a/test/flow/graph.cpp b/test/flow/graph.cpp
index ebcff152..2d9431bc 100644
--- a/test/flow/graph.cpp
+++ b/test/flow/graph.cpp
@@ -26,12 +26,12 @@ TEST_CASE("node size (empty graph)", "[graph]") {
 }
 
 TEST_CASE("node size (single action)", "[graph]") {
-    constexpr auto g = flow::graph<>{}.add(a >> b);
+    constexpr auto g = flow::graph<>{}.add(*a >> *b);
     static_assert(node_size(g) == 2);
 }
 
 TEST_CASE("node size (overlapping actions)", "[graph]") {
-    constexpr auto g = flow::graph<>{}.add(a >> b).add(b >> c);
+    constexpr auto g = flow::graph<>{}.add(*a >> *b).add(b >> *c);
     static_assert(node_size(g) == 3);
 }
 
@@ -41,11 +41,11 @@ TEST_CASE("edge size (empty flow)", "[graph]") {
 }
 
 TEST_CASE("edge size (single action)", "[graph]") {
-    constexpr auto g = flow::graph<>{}.add(a >> b);
+    constexpr auto g = flow::graph<>{}.add(*a >> *b);
     static_assert(edge_size(g) == 1);
 }
 
 TEST_CASE("edge size (overlapping actions)", "[graph]") {
-    constexpr auto g = flow::graph<>{}.add(a >> b).add(b >> c);
+    constexpr auto g = flow::graph<>{}.add(*a >> *b).add(*b >> *c);
     static_assert(edge_size(g) == 2);
 }
diff --git a/test/flow/graph_builder.cpp b/test/flow/graph_builder.cpp
index 5feeb342..c0deebfb 100644
--- a/test/flow/graph_builder.cpp
+++ b/test/flow/graph_builder.cpp
@@ -4,6 +4,7 @@
 #include <catch2/catch_test_macros.hpp>
 
 #include <string>
+#include <string_view>
 
 namespace {
 auto actual = std::string{};
@@ -16,115 +17,98 @@ constexpr auto b = flow::action<"b">([] { actual += "b"; });
 constexpr auto c = flow::action<"c">([] { actual += "c"; });
 constexpr auto d = flow::action<"d">([] { actual += "d"; });
 
-using builder = flow::graph_builder<flow::impl>;
+using builder = flow::graph_builder<"test_flow", flow::impl>;
 } // namespace
 
-struct empty_flow {
-    constexpr static auto value = flow::graph<>{};
-};
-TEST_CASE("build and run empty flow", "[graph_builder]") {
-    constexpr auto f = builder::render<empty_flow>();
-    f();
-}
+template <auto... Vs> struct run_flow_t {
+    struct wrapper {
+        constexpr static auto value = flow::graph<>{}.add(Vs...);
+    };
 
-struct single_action {
-    constexpr static auto value = flow::graph<>{}.add(a);
+    auto operator()() const -> void { builder::render<wrapper>()(); }
 };
-TEST_CASE("add single action", "[graph_builder]") {
+
+template <auto... Vs> constexpr auto run_flow = run_flow_t<Vs...>{};
+
+template <auto... Vs> auto check_flow(std::string_view expected) -> void {
     actual.clear();
-    constexpr auto f = builder::render<single_action>();
-    f();
-    CHECK(actual == "a");
+    run_flow<Vs...>();
+    CHECK(actual == expected);
 }
 
-struct two_milestone_linear_before {
-    constexpr static auto value = flow::graph<>{}.add(a >> milestone0);
-};
+#if defined(__GNUC__) && __GNUC__ == 12
+#else
+
+TEST_CASE("build and run empty flow", "[graph_builder]") { check_flow<>(""); }
+
+TEST_CASE("add single action", "[graph_builder]") { check_flow<*a>("a"); }
+
 TEST_CASE("two milestone linear before dependency", "[graph_builder]") {
-    actual.clear();
-    constexpr auto f = builder::render<two_milestone_linear_before>();
-    f();
-    CHECK(actual == "a");
+    check_flow<(*a >> *milestone0)>("a");
 }
 
-struct actions_get_executed_once {
-    constexpr static auto value = flow::graph<>{}
-                                      .add(a >> milestone0)
-                                      .add(a >> milestone1)
-                                      .add(milestone0 >> milestone1);
-};
 TEST_CASE("actions get executed once", "[graph_builder]") {
-    actual.clear();
-    constexpr auto f = builder::render<actions_get_executed_once>();
-    f();
-    CHECK(actual == "a");
+    check_flow<(*a >> *milestone0), (a >> *milestone1),
+               (milestone0 >> milestone1)>("a");
 }
 
-struct two_milestone_linear_after_dependency {
-    constexpr static auto value = flow::graph<>{}
-                                      .add(a >> milestone0)
-                                      .add(milestone0 >> milestone1)
-                                      .add(milestone0 >> b >> milestone1);
-};
 TEST_CASE("two milestone linear after dependency", "[graph_builder]") {
-    actual.clear();
-    constexpr auto f = builder::render<two_milestone_linear_after_dependency>();
-    f();
-    CHECK(actual == "ab");
+    check_flow<(*a >> *milestone0), (milestone0 >> *milestone1),
+               (milestone0 >> *b >> milestone1)>("ab");
 }
 
-struct three_milestone_linear_before_and_after_dependency {
-    constexpr static auto value = flow::graph<>{}.add(a >> b >> c);
-};
 TEST_CASE("three milestone linear before and after dependency",
           "[graph_builder]") {
-    actual.clear();
-    constexpr auto f =
-        builder::render<three_milestone_linear_before_and_after_dependency>();
-    f();
-    CHECK(actual == "abc");
+    check_flow<(*a >> *b >> *c)>("abc");
 }
 
-struct just_two_actions_in_order {
-    constexpr static auto value = flow::graph<>{}.add(a >> b);
-};
 TEST_CASE("just two actions in order", "[graph_builder]") {
-    actual.clear();
-    constexpr auto f = builder::render<just_two_actions_in_order>();
-    f();
-    CHECK(actual == "ab");
+    check_flow<(*a >> *b)>("ab");
+}
+
+TEST_CASE("operator* on two actions in order", "[graph_builder]") {
+    check_flow<*(a >> b)>("ab");
+}
+
+TEST_CASE("operator* on three actions in order", "[graph_builder]") {
+    check_flow<*(a >> b >> c)>("abc");
 }
 
-struct insert_action_between_two_actions {
-    constexpr static auto value = flow::graph<>{}.add(a >> c).add(a >> b >> c);
-};
 TEST_CASE("insert action between two actions", "[graph_builder]") {
-    actual.clear();
-    constexpr auto f = builder::render<insert_action_between_two_actions>();
-    f();
-    CHECK(actual == "abc");
+    check_flow<(*a >> *c), (a >> *b >> c)>("abc");
 }
 
-struct add_single_parallel_2 {
-    constexpr static auto value = flow::graph<>{}.add(a && b);
-};
 TEST_CASE("add single parallel 2", "[graph_builder]") {
     actual.clear();
-    constexpr auto f = builder::render<add_single_parallel_2>();
-    f();
+    run_flow<*a && *b>();
 
     CHECK(actual.find('a') != std::string::npos);
     CHECK(actual.find('b') != std::string::npos);
     CHECK(actual.size() == 2);
 }
 
-struct add_single_parallel_3 {
-    constexpr static auto value = flow::graph<>{}.add(a && b && c);
-};
+TEST_CASE("operator* on add single parallel 2", "[graph_builder]") {
+    actual.clear();
+    run_flow<*(a && b)>();
+
+    CHECK(actual.find('a') != std::string::npos);
+    CHECK(actual.find('b') != std::string::npos);
+    CHECK(actual.size() == 2);
+}
+
+TEST_CASE("operator* on double parallel", "[graph_builder]") {
+    actual.clear();
+    run_flow<*(a && b && c)>();
+
+    CHECK(actual.find('a') != std::string::npos);
+    CHECK(actual.find('b') != std::string::npos);
+    CHECK(actual.find('c') != std::string::npos);
+    CHECK(actual.size() == 3);
+}
+
 TEST_CASE("add single parallel 3", "[graph_builder]") {
     actual.clear();
-    constexpr auto f = builder::render<add_single_parallel_3>();
-    f();
+    run_flow<*a && *b && *c>();
 
     CHECK(actual.find('a') != std::string::npos);
     CHECK(actual.find('b') != std::string::npos);
@@ -132,14 +116,9 @@ TEST_CASE("add single parallel 3", "[graph_builder]") {
     CHECK(actual.size() == 3);
 }
 
-struct add_single_parallel_3_with_later_dependency_1 {
-    constexpr static auto value = flow::graph<>{}.add(a && b && c).add(c >> a);
-};
 TEST_CASE("add single parallel 3 with later dependency 1", "[graph_builder]") {
     actual.clear();
-    constexpr auto f =
-        builder::render<add_single_parallel_3_with_later_dependency_1>();
-    f();
+    run_flow<*a && *b && *c, (c >> a)>();
 
     CHECK(actual.find('a') != std::string::npos);
     CHECK(actual.find('b') != std::string::npos);
@@ -148,14 +127,9 @@ TEST_CASE("add single parallel 3 with later dependency 1", "[graph_builder]") {
     CHECK(actual.size() == 3);
 }
 
-struct add_single_parallel_3_with_later_dependency_2 {
-    constexpr static auto value = flow::graph<>{}.add(a && b && c).add(a >> c);
-};
 TEST_CASE("add single parallel 3 with later dependency 2", "[graph_builder]") {
     actual.clear();
-    constexpr auto f =
-        builder::render<add_single_parallel_3_with_later_dependency_2>();
-    f();
+    run_flow<*a && *b && *c, (a >> c)>();
 
     CHECK(actual.find('a') != std::string::npos);
     CHECK(actual.find('b') != std::string::npos);
@@ -164,13 +138,9 @@ TEST_CASE("add single parallel 3 with later dependency 2", "[graph_builder]") {
     CHECK(actual.size() == 3);
 }
 
-struct add_parallel_rhs {
-    constexpr static auto value = flow::graph<>{}.add(a >> (b && c));
-};
 TEST_CASE("add parallel rhs", "[graph_builder]") {
     actual.clear();
-    constexpr auto f = builder::render<add_parallel_rhs>();
-    f();
+    run_flow<(*a >> (*b && *c))>();
 
     CHECK(actual.find('a') != std::string::npos);
     CHECK(actual.find('b') != std::string::npos);
@@ -180,13 +150,9 @@ TEST_CASE("add parallel rhs", "[graph_builder]") {
     CHECK(actual.size() == 3);
 }
 
-struct add_parallel_lhs {
-    constexpr static auto value = flow::graph<>{}.add((a && b) >> c);
-};
 TEST_CASE("add parallel lhs", "[graph_builder]") {
     actual.clear();
-    constexpr auto f = builder::render<add_parallel_lhs>();
-    f();
+    run_flow<((*a && *b) >> *c)>();
 
     CHECK(actual.find('a') != std::string::npos);
     CHECK(actual.find('b') != std::string::npos);
@@ -196,13 +162,9 @@ TEST_CASE("add parallel lhs", "[graph_builder]") {
     CHECK(actual.size() == 3);
 }
 
-struct add_parallel_in_the_middle {
-    constexpr static auto value = flow::graph<>{}.add(a >> (b && c) >> d);
-};
 TEST_CASE("add parallel in the middle", "[graph_builder]") {
     actual.clear();
-    constexpr auto f = builder::render<add_parallel_in_the_middle>();
-    f();
+    run_flow<(*a >> (*b && *c) >> *d)>();
 
     CHECK(actual.find('a') != std::string::npos);
     CHECK(actual.find('b') != std::string::npos);
@@ -218,13 +180,9 @@ TEST_CASE("add parallel in the middle", "[graph_builder]") {
     CHECK(actual.size() == 4);
 }
 
-struct add_dependency_lhs {
-    constexpr static auto value = flow::graph<>{}.add((a >> b) && c);
-};
 TEST_CASE("add dependency lhs", "[graph_builder]") {
     actual.clear();
-    constexpr auto f = builder::render<add_dependency_lhs>();
-    f();
+    run_flow<(*a >> *b) && *c>();
 
     CHECK(actual.find('a') != std::string::npos);
     CHECK(actual.find('b') != std::string::npos);
@@ -235,13 +193,9 @@ TEST_CASE("add dependency lhs", "[graph_builder]") {
     CHECK(actual.size() == 3);
 }
 
-struct add_dependency_rhs {
-    constexpr static auto value = flow::graph<>{}.add(a && (b >> c));
-};
 TEST_CASE("add dependency rhs", "[graph_builder]") {
     actual.clear();
-    constexpr auto f = builder::render<add_dependency_rhs>();
-    f();
+    run_flow<*a && (*b >> *c)>();
 
     CHECK(actual.find('a') != std::string::npos);
     CHECK(actual.find('b') != std::string::npos);
@@ -252,9 +206,21 @@ TEST_CASE("add dependency rhs", "[graph_builder]") {
     CHECK(actual.size() == 3);
 }
 
+TEST_CASE("reference vs non-reference", "[graph_builder]") {
+    static_assert(a.identity == flow::subgraph_identity::REFERENCE);
+    static_assert((*a).identity == flow::subgraph_identity::VALUE);
+}
+
+TEST_CASE("reference in order with non-reference added twice",
+          "[graph_builder]") {
+    check_flow<(*a >> b) && (*b)>("ab");
+}
+
+#endif
+
 TEST_CASE("alternate builder", "[graph_builder]") {
     using alt_builder = flow::graphviz_builder;
-    auto g = flow::graph<"debug">{}.add(a && (b >> c));
+    auto g = flow::graph<"debug">{}.add(*a && (*b >> *c));
     auto const flow = alt_builder::build(g);
     auto expected = std::string{
         R"__debug__(digraph debug {
diff --git a/test/msg/handler_builder.cpp b/test/msg/handler_builder.cpp
index 2e3ed5d6..c8731c5e 100644
--- a/test/msg/handler_builder.cpp
+++ b/test/msg/handler_builder.cpp
@@ -36,6 +36,16 @@ struct test_project {
         cib::exports<test_service>, cib::extend<test_service>(test_callback));
 };
 
+template <bool V>
+constexpr auto when_feature_enabled =
+    cib::runtime_condition<"feature_a_enabled">([] { return V; });
+
+template <bool V> struct runtime_condition_project {
+    constexpr static auto config = cib::config(
+        cib::exports<test_service>,
+        when_feature_enabled<V>(cib::extend<test_service>(test_callback)));
+};
+
 std::string log_buffer{};
 } // namespace
 
@@ -52,6 +62,33 @@ TEST_CASE("build handler", "[handler_builder]") {
     CHECK(callback_success);
 }
 
+TEST_CASE("build handler (no match)", "[handler_builder]") {
+    cib::nexus<test_project> test_nexus{};
+    test_nexus.init();
+
+    callback_success = false;
+    cib::service<test_service>->handle(test_msg_t{"id"_field = 0x70});
+    CHECK(not callback_success);
+}
+
+TEST_CASE("true runtime condition", "[handler_builder]") {
+    cib::nexus<runtime_condition_project<true>> test_nexus{};
+    test_nexus.init();
+
+    callback_success = false;
+    cib::service<test_service>->handle(test_msg_t{"id"_field = 0x80});
+    CHECK(callback_success);
+}
+
+TEST_CASE("false runtime condition", "[handler_builder]") {
+    cib::nexus<runtime_condition_project<false>> test_nexus{};
+    test_nexus.init();
+
+    callback_success = false;
+    cib::service<test_service>->handle(test_msg_t{"id"_field = 0x80});
+    CHECK(not callback_success);
+}
+
 TEST_CASE("match output success", "[handler_builder]") {
     log_buffer.clear();
     cib::nexus<test_project> test_nexus{};
diff --git a/test/msg/indexed_builder.cpp b/test/msg/indexed_builder.cpp
index 107b4854..ebe12739 100644
--- a/test/msg/indexed_builder.cpp
+++ b/test/msg/indexed_builder.cpp
@@ -41,6 +41,16 @@ struct test_project {
         cib::exports<test_service>, cib::extend<test_service>(test_callback));
 };
 
+template <bool V>
+constexpr auto when_feature_enabled =
+    cib::runtime_condition<"feature_a_enabled">([] { return V; });
+
+template <bool V> struct runtime_condition_project {
+    constexpr static auto config = cib::config(
+        cib::exports<test_service>,
+        when_feature_enabled<V>(cib::extend<test_service>(test_callback)));
+};
+
 std::string log_buffer{};
 } // namespace
 
@@ -63,7 +73,27 @@ TEST_CASE("build handler", "[indexed_builder]") {
     CHECK(not callback_success);
 }
 
-TEST_CASE("match output success", "[handler_builder]") {
+TEST_CASE("true runtime condition", "[indexed_builder]") {
+    cib::nexus<runtime_condition_project<true>> test_nexus{};
+    test_nexus.init();
+
+    callback_success = false;
+    cib::service<test_service>->handle(
+        test_msg_t{"test_id_field"_field = 0x80});
+    CHECK(callback_success);
+}
+
+TEST_CASE("false runtime condition", "[indexed_builder]") {
+    cib::nexus<runtime_condition_project<false>> test_nexus{};
+    test_nexus.init();
+
+    callback_success = false;
+    cib::service<test_service>->handle(
+        test_msg_t{"test_id_field"_field = 0x80});
+    CHECK(not callback_success);
+}
+
+TEST_CASE("match output success", "[indexed_builder]") {
     log_buffer.clear();
     cib::nexus<test_project> test_nexus{};
     test_nexus.init();
@@ -76,7 +106,7 @@ TEST_CASE("match output success", "[handler_builder]") {
     CHECK(log_buffer.find("[test_id_field == 0x80]") != std::string::npos);
 }
 
-TEST_CASE("match output failure", "[handler_builder]") {
+TEST_CASE("match output failure", "[indexed_builder]") {
     log_buffer.clear();
     cib::nexus<test_project> test_nexus{};
     test_nexus.init();
@@ -330,7 +360,7 @@ struct test_msg_match_project {
 };
 } // namespace
 
-TEST_CASE("match output success (message matcher)", "[handler_builder]") {
+TEST_CASE("match output success (message matcher)", "[indexed_builder]") {
     log_buffer.clear();
     cib::nexus<test_msg_match_project> test_nexus{};
     test_nexus.init();
@@ -384,7 +414,7 @@ struct test_project_extra_args {
 };
 } // namespace
 
-TEST_CASE("handle extra arguments", "[handler_builder]") {
+TEST_CASE("handle extra arguments", "[indexed_builder]") {
     cib::nexus<test_project_extra_args> test_nexus{};
     test_nexus.init();
 
diff --git a/test/seq/sequencer.cpp b/test/seq/sequencer.cpp
index 4e8b2824..945e3397 100644
--- a/test/seq/sequencer.cpp
+++ b/test/seq/sequencer.cpp
@@ -10,7 +10,7 @@ namespace {
 int attempt_count;
 std::string result{};
 
-using builder = flow::graph_builder<seq::impl>;
+using builder = flow::graph_builder<"test_seq", seq::impl>;
 } // namespace
 
 TEST_CASE("build and run empty seq", "[seq]") {
@@ -34,7 +34,7 @@ TEST_CASE("build seq with one step and run forwards and backwards", "[seq]") {
             return seq::status::DONE;
         });
 
-    auto g = seq::builder<>{}.add(s);
+    auto g = seq::builder<>{}.add(*s);
     auto seq_impl = builder::build(g);
     REQUIRE(seq_impl.has_value());
 
@@ -64,7 +64,7 @@ TEST_CASE("build seq with a forward step that takes a while to finish",
             return seq::status::DONE;
         });
 
-    auto g = seq::builder<>{}.add(s);
+    auto g = seq::builder<>{}.add(*s);
     auto seq_impl = builder::build(g);
     REQUIRE(seq_impl.has_value());
 
@@ -110,7 +110,7 @@ TEST_CASE("build seq with a backward step that takes a while to finish",
             }
         });
 
-    auto g = seq::builder<>{}.add(s);
+    auto g = seq::builder<>{}.add(*s);
     auto seq_impl = builder::build(g);
     REQUIRE(seq_impl.has_value());
 
@@ -175,7 +175,7 @@ TEST_CASE("build seq with three steps and run forwards and backwards",
             return seq::status::DONE;
         });
 
-    auto g = seq::builder<>{}.add(s1 >> s2 >> s3);
+    auto g = seq::builder<>{}.add(*s1 >> *s2 >> *s3);
     auto seq_impl = builder::build(g);
     REQUIRE(seq_impl.has_value());