@@ -268,6 +268,7 @@ add_executable(o2-test-framework-core
               test/test_TopologyPolicies.cxx
               test/test_Variants.cxx
               test/test_WorkflowHelpers.cxx
+              test/test_WorkflowDefinition.cxx
               test/test_WorkflowSerialization.cxx
               test/test_DataOutputDirector.cxx
               test/unittest_SimpleOptionsRetriever.cxx
@@ -447,6 +448,32 @@ o2_add_test(
     "--global-config consumer-config --local-option hello-aliceo2 --a-boolean3 --an-int2 20 --a-double2 22. --an-int64-2 50000000000000"
   )
 
+# runs the workflows of two plugins built in DSOs, loaded with --workflow-plugin
+o2_add_test(
+  WorkflowPlugins NAME test_Framework_test_WorkflowPlugins
+  SOURCES test/test_WorkflowPlugins.cxx
+  COMPONENT_NAME Framework
+  LABELS framework workflow
+  TIMEOUT 30
+  PUBLIC_LINK_LIBRARIES O2::Framework
+  TARGETVARNAME workflowPluginsTest
+  NO_BOOST_TEST
+  COMMAND_LINE_ARGS
+    --workflow-plugin O2FrameworkTestWorkflowPluginA:TestWorkflowPluginA,O2FrameworkTestWorkflowPluginB:TestWorkflowPluginB
+    --shared 3 --run --shm-segment-size 20000000 ${DPL_WORKFLOW_TESTS_EXTRA_OPTIONS}
+  ENVIRONMENT "DYLD_LIBRARY_PATH=${CMAKE_LIBRARY_OUTPUT_DIRECTORY}:$ENV{DYLD_LIBRARY_PATH};LD_LIBRARY_PATH=${CMAKE_LIBRARY_OUTPUT_DIRECTORY}:$ENV{LD_LIBRARY_PATH}"
+  )
+if(workflowPluginsTest)
+  foreach(p A B)
+    add_library(O2FrameworkTestWorkflowPlugin${p} SHARED test/test_WorkflowPlugin${p}.cxx)
+    target_link_libraries(O2FrameworkTestWorkflowPlugin${p} PRIVATE O2::Framework)
+    target_compile_definitions(O2FrameworkTestWorkflowPlugin${p} PRIVATE
+                               DPL_WORKFLOW_PLUGIN_NAME=TestWorkflowPlugin${p}
+                               DPL_WORKFLOW_PLUGIN_LIBRARY=O2FrameworkTestWorkflowPlugin${p})
+    add_dependencies(${workflowPluginsTest} O2FrameworkTestWorkflowPlugin${p})
+  endforeach()
+endif()
+
 # the test is compiled from the ExternalFairMQDeviceWorkflow test and run with
 # command line option to include the output proxy
 o2_add_test(
 
@@ -50,12 +50,23 @@ struct WorkflowDefinitionContext {
 };
 
 struct WorkflowDefinition {
-  std::function<o2::framework::WorkflowDefinitionContext(int argc, char** argv)> defineWorkflow;
+  /// Fills the workflow options and the policies the plugin customises.
+  std::function<void(o2::framework::WorkflowDefinitionContext& context)> customize;
+  /// Fills the data processors and the channel policies of the plugin,
+  /// using the workflow options parsed in @a configContext.
+  std::function<void(o2::framework::WorkflowDefinitionContext& context, o2::framework::ConfigContext& configContext)> defineWorkflow;
 };
 
 struct WorkflowPlugin {
   virtual o2::framework::WorkflowDefinition* create() = 0;
 };
 
+/// Defines the workflow made of all the @a definitions, called @a names in errors.
+/// The workflow options of all of them are parsed once from @a argc / @a argv, then
+/// their data processors and policies are merged, in the order of @a definitions.
+/// An option may be declared by several definitions only with the same type and default,
+/// and a data processor name may not be used by more than one definition.
+WorkflowDefinitionContext defineWorkflow(std::vector<WorkflowDefinition> const& definitions, std::vector<std::string> const& names, int argc, char** argv);
+
 } // namespace o2::framework
 #endif // O2_FRAMEWORK_WORKFLOWDEFINITIONCONTEXT_H_
@@ -185,33 +185,22 @@ struct DPL_WORKFLOW_PLUGIN_NAME : o2::framework::WorkflowPlugin {
   o2::framework::WorkflowDefinition* create() override
   {
     return new o2::framework::WorkflowDefinition{
-      .defineWorkflow = [](int argc, char** argv) -> o2::framework::WorkflowDefinitionContext {
+      .customize = [](o2::framework::WorkflowDefinitionContext& workflowContext) {
         using namespace o2::framework;
-        WorkflowDefinitionContext workflowContext;
-
         UserCustomizationsHelper::userDefinedCustomization(workflowContext.workflowOptions);
-        auto requiredWorkflowOptions = WorkflowCustomizationHelpers::requiredWorkflowOptions();
-        workflowContext.workflowOptions.insert(std::end(workflowContext.workflowOptions), std::begin(requiredWorkflowOptions), std::end(requiredWorkflowOptions));
-
-        workflowContext.completionPolicies = injectCustomizations<CompletionPolicy>();
-        workflowContext.dispatchPolicies = injectCustomizations<DispatchPolicy>();
-        workflowContext.resourcePolicies = injectCustomizations<ResourcePolicy>();
-        workflowContext.callbacksPolicies = injectCustomizations<CallbacksPolicy>();
-        workflowContext.sendingPolicies = injectCustomizations<SendingPolicy>();
-
-        workflowContext.configRegistry = createRegistry();
-        workflowContext.configContext = createConfigContext(workflowContext.workflowOptionsRegistry, *workflowContext.configRegistry, workflowContext.workflowOptions, workflowContext.extraOptions, argc, argv);
-
-        workflowContext.specs = defineDataProcessing(*workflowContext.configContext);
-        overrideAll(*workflowContext.configContext, workflowContext.specs);
+        UserCustomizationsHelper::userDefinedCustomization(workflowContext.completionPolicies);
+        UserCustomizationsHelper::userDefinedCustomization(workflowContext.dispatchPolicies);
+        UserCustomizationsHelper::userDefinedCustomization(workflowContext.resourcePolicies);
+        UserCustomizationsHelper::userDefinedCustomization(workflowContext.callbacksPolicies);
+        UserCustomizationsHelper::userDefinedCustomization(workflowContext.sendingPolicies); },
+      .defineWorkflow = [](o2::framework::WorkflowDefinitionContext& workflowContext, o2::framework::ConfigContext& configContext) {
+        using namespace o2::framework;
+        workflowContext.specs = defineDataProcessing(configContext);
+        overrideAll(configContext, workflowContext.specs);
         for (auto& spec : workflowContext.specs) {
           UserCustomizationsHelper::userDefinedCustomization(spec.requiredServices);
         }
-        UserCustomizationsHelper::userDefinedCustomization(workflowContext.channelPolicies);
-        auto defaultChannelPolicies = ChannelConfigurationPolicy::createDefaultPolicies(*workflowContext.configContext);
-        workflowContext.channelPolicies.insert(std::end(workflowContext.channelPolicies), std::begin(defaultChannelPolicies), std::end(defaultChannelPolicies));
-        return workflowContext;
-      }};
+        UserCustomizationsHelper::userDefinedCustomization(workflowContext.channelPolicies); }};
   }
 };
 
 
@@ -1490,6 +1490,8 @@ void DeviceSpecHelpers::prepareArguments(bool defaultQuiet, bool defaultStopped,
     auto forwardedOptions = getForwardedDeviceOptions();
     /// Add to foDesc the options which are not already there
     foDesc.add(forwardedOptions);
+    // Children need the same workflow plugins to define the same workflow.
+    foDesc.add_options()("workflow-plugin", bpo::value<std::string>());
 
     // has option --session been specified on the command line?
     bool haveSessionArg = false;
 
@@ -66,6 +66,7 @@
 #include "Framework/ServiceMetricsInfo.h"
 #include "Framework/DataTakingContext.h"
 #include "Framework/WorkflowDefinitionContext.h"
+#include "Framework/WorkflowCustomizationHelpers.h"
 #include "Framework/CommonServices.h"
 #include "Framework/DefaultsHelpers.h"
 #include "ProcessingPoliciesHelpers.h"
@@ -202,19 +203,35 @@ int doMain(int argc, char** argv, o2::framework::WorkflowDefinitionContext& work
 int callMain(int argc, char** argv, char const* pluginSpec, DPLPluginHandle* (*embeddedPlugins)(DPLPluginHandle*))
 {
   auto mainNoCatch = [pluginSpec, embeddedPlugins](int argc, char** argv) {
-    auto plugins = PluginManager::parsePluginSpecString(pluginSpec);
+    // --workflow-plugin replaces the plugin embedded in the executable.
+    char const* spec = pluginSpec;
+    for (int ai = 1; ai < argc; ++ai) {
+      if (strcmp(argv[ai], "--workflow-plugin") == 0 && ai + 1 < argc) {
+        spec = argv[ai + 1];
+      } else if (strncmp(argv[ai], "--workflow-plugin=", 18) == 0) {
+        spec = argv[ai] + 18;
+      }
+    }
+    auto plugins = PluginManager::parsePluginSpecString(spec);
     std::vector<WorkflowDefinition> workflows;
-    if (plugins.size() == 1 && plugins[0].library.empty()) {
-      if (auto* plugin = PluginManager::getByName<WorkflowPlugin>(embeddedPlugins(nullptr), plugins[0].name.c_str())) {
-        workflows.push_back(*plugin->create());
+    std::vector<std::string> names;
+    for (auto& plugin : plugins) {
+      if (plugin.library.empty()) {
+        if (auto* embedded = PluginManager::getByName<WorkflowPlugin>(embeddedPlugins(nullptr), plugin.name.c_str())) {
+          workflows.push_back(*embedded->create());
+        }
+      } else {
+        PluginManager::loadFromPlugin<WorkflowDefinition, WorkflowPlugin>({plugin}, workflows);
+      }
+      names.push_back(plugin.library + ":" + plugin.name);
+      if (workflows.size() != names.size()) {
+        throw runtime_error_f("Could not load the workflow plugin %s.", names.back().c_str());
       }
-    } else {
-      PluginManager::loadFromPlugin<WorkflowDefinition, WorkflowPlugin>(plugins, workflows);
     }
-    if (workflows.size() != 1) {
-      throw runtime_error_f("Expected exactly one workflow plugin in %s, found %zu.", pluginSpec, workflows.size());
+    if (workflows.empty()) {
+      throw runtime_error_f("No workflow plugin in %s.", spec);
     }
-    auto workflowContext = workflows.back().defineWorkflow(argc, argv);
+    auto workflowContext = defineWorkflow(workflows, names, argc, argv);
     return doMain(argc, argv, workflowContext);
   };
   static bool noCatch = getenv("O2_NO_CATCHALL_EXCEPTIONS") && strcmp(getenv("O2_NO_CATCHALL_EXCEPTIONS"), "0");
@@ -1085,6 +1102,7 @@ int doChild(int argc, char** argv, ServiceRegistry& serviceRegistry,
       ("data-processing-timeout", bpo::value<std::string>()->default_value(defaultDataProcessingTimeout), "how many second to wait before stopping data processing and allowing data calibration") //
       ("timeframes-rate-limit", bpo::value<std::string>()->default_value("0"), "how many timeframe can be in flight at the same moment (0 disables)")                                              //
       ("configuration,cfg", bpo::value<std::string>()->default_value("command-line"), "configuration backend")                                                                                     //
+      ("workflow-plugin", bpo::value<std::string>(), "workflow plugins to load")                                                                                                                   //
       ("infologger-mode", bpo::value<std::string>()->default_value(defaultInfologgerMode), "O2_INFOLOGGER_MODE override")                                                                          //
       ("log-timestamp-us", bpo::value<bool>()->zero_tokens()->default_value(false), "enable microsecond timestamps in log messages");
     r.fConfig.AddToCmdLineOptions(optsDesc, true);
@@ -2926,6 +2944,59 @@ std::unique_ptr<o2::framework::ServiceRegistry> createRegistry()
   return std::make_unique<o2::framework::ServiceRegistry>();
 }
 
+o2::framework::WorkflowDefinitionContext o2::framework::defineWorkflow(std::vector<WorkflowDefinition> const& definitions, std::vector<std::string> const& names, int argc, char** argv)
+{
+  auto append = [](auto& to, auto const& from) { to.insert(to.end(), from.begin(), from.end()); };
+  auto toString = [](Variant const& value) { std::ostringstream oss; oss << value; return oss.str(); };
+  WorkflowDefinitionContext result;
+  std::vector<WorkflowDefinitionContext> contexts(definitions.size());
+  for (size_t di = 0; di < definitions.size(); ++di) {
+    auto& context = contexts[di];
+    definitions[di].customize(context);
+    // Options already declared by a previous definition are shared, if they agree.
+    auto previous = result.workflowOptions.size();
+    for (auto& option : context.workflowOptions) {
+      auto end = result.workflowOptions.begin() + previous;
+      auto found = std::find_if(result.workflowOptions.begin(), end, [&option](auto const& other) { return other.name == option.name; });
+      if (found == end) {
+        result.workflowOptions.push_back(option);
+      } else if (found->type != option.type || toString(found->defaultValue) != toString(option.defaultValue)) {
+        throw runtime_error_f("Workflow option %s of %s has a different type or default than in a previous plugin.", option.name.c_str(), names[di].c_str());
+      }
+    }
+    append(result.completionPolicies, context.completionPolicies);
+    append(result.dispatchPolicies, context.dispatchPolicies);
+    append(result.resourcePolicies, context.resourcePolicies);
+    append(result.callbacksPolicies, context.callbacksPolicies);
+    append(result.sendingPolicies, context.sendingPolicies);
+  }
+  append(result.workflowOptions, WorkflowCustomizationHelpers::requiredWorkflowOptions());
+  append(result.completionPolicies, CompletionPolicy::createDefaultPolicies());
+  append(result.dispatchPolicies, DispatchPolicy::createDefaultPolicies());
+  append(result.resourcePolicies, ResourcePolicy::createDefaultPolicies());
+  append(result.callbacksPolicies, CallbacksPolicy::createDefaultPolicies());
+  append(result.sendingPolicies, SendingPolicy::createDefaultPolicies());
+
+  result.configRegistry = createRegistry();
+  result.configContext = createConfigContext(result.workflowOptionsRegistry, *result.configRegistry, result.workflowOptions, result.extraOptions, argc, argv);
+
+  std::map<std::string, size_t> definedBy;
+  for (size_t di = 0; di < definitions.size(); ++di) {
+    auto& context = contexts[di];
+    definitions[di].defineWorkflow(context, *result.configContext);
+    for (auto& spec : context.specs) {
+      auto [it, inserted] = definedBy.try_emplace(spec.name, di);
+      if (!inserted && it->second != di) {
+        throw runtime_error_f("Data processor %s is defined by both %s and %s.", spec.name.c_str(), names[it->second].c_str(), names[di].c_str());
+      }
+    }
+    append(result.specs, context.specs);
+    append(result.channelPolicies, context.channelPolicies);
+  }
+  append(result.channelPolicies, ChannelConfigurationPolicy::createDefaultPolicies(*result.configContext));
+  return result;
+}
+
 // This is a toy executor for the workflow spec
 // What it needs to do is:
 //
@@ -3010,6 +3081,7 @@ int doMain(int argc, char** argv, o2::framework::WorkflowDefinitionContext& work
     ("id,i", bpo::value<std::string>(), "device id for child spawning")                 //
     ("channel-config", bpo::value<std::vector<std::string>>(), "channel configuration") //
     ("control", "control plugin")                                                       //
+    ("workflow-plugin", bpo::value<std::string>(), "workflow plugins to load")          //
     ("log-color", "logging color scheme")("color", "logging color scheme");
 
   bpo::options_description visibleOptions;
 
@@ -0,0 +1,95 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "Framework/WorkflowDefinitionContext.h"
+#include "Framework/CompletionPolicyHelpers.h"
+#include <catch_amalgamated.hpp>
+#include <algorithm>
+
+using namespace o2::framework;
+
+namespace
+{
+// A plugin with a processor called @a processor, which declares the
+// workflow options @a options and records the value of "shared" it sees.
+WorkflowDefinition makeDefinition(std::string processor, std::vector<ConfigParamSpec> options, int& shared)
+{
+  return WorkflowDefinition{
+    .customize = [processor, options](WorkflowDefinitionContext& context) {
+      context.workflowOptions = options;
+      context.completionPolicies.push_back(CompletionPolicyHelpers::consumeWhenAll(processor.c_str(), [](auto const&) { return false; })); },
+    .defineWorkflow = [processor, &shared](WorkflowDefinitionContext& context, ConfigContext& configContext) {
+      shared = configContext.options().get<int>("shared");
+      context.specs.push_back(DataProcessorSpec{.name = processor}); }};
+}
+
+size_t countOption(WorkflowDefinitionContext const& context, std::string const& name)
+{
+  return std::count_if(context.workflowOptions.begin(), context.workflowOptions.end(), [&name](auto const& option) { return option.name == name; });
+}
+} // namespace
+
+TEST_CASE("TestMergeWorkflowDefinitions")
+{
+  int sharedA = 0;
+  int sharedB = 0;
+  std::vector<WorkflowDefinition> definitions{
+    makeDefinition("a", {{"shared", VariantType::Int, 1, {"shared option"}}, {"a-only", VariantType::Int, 2, {"option of a"}}}, sharedA),
+    makeDefinition("b", {{"shared", VariantType::Int, 1, {"shared option"}}, {"b-only", VariantType::String, "x", {"option of b"}}}, sharedB)};
+  char const* args[] = {"test", "--shared", "3", "--b-only", "y"};
+  auto context = defineWorkflow(definitions, {"libA:a", "libB:b"}, 5, const_cast<char**>(args));
+
+  // Options are parsed once and each plugin sees the value of the shared one.
+  REQUIRE(countOption(context, "shared") == 1);
+  REQUIRE(countOption(context, "a-only") == 1);
+  REQUIRE(countOption(context, "b-only") == 1);
+  REQUIRE(sharedA == 3);
+  REQUIRE(sharedB == 3);
+  REQUIRE(context.configContext->options().get<std::string>("b-only") == "y");
+  // Options of the plugins come first, then those required by DPL.
+  REQUIRE(context.workflowOptions[0].name == "shared");
+  REQUIRE(context.workflowOptions[1].name == "a-only");
+  REQUIRE(context.workflowOptions[2].name == "b-only");
+  REQUIRE(countOption(context, "pipeline") == 1);
+
+  // Data processors and policies are merged in plugin order, the default policies last.
+  REQUIRE(context.specs.size() == 2);
+  REQUIRE(context.specs[0].name == "a");
+  REQUIRE(context.specs[1].name == "b");
+  REQUIRE(context.completionPolicies.size() == 2 + CompletionPolicy::createDefaultPolicies().size());
+  REQUIRE(context.completionPolicies[0].name == "a");
+  REQUIRE(context.completionPolicies[1].name == "b");
+  REQUIRE(context.completionPolicies[2].name == CompletionPolicy::createDefaultPolicies()[0].name);
+}
+
+TEST_CASE("TestConflictingWorkflowOptions")
+{
+  int shared = 0;
+  char const* args[] = {"test"};
+  // Same option with a different default.
+  std::vector<WorkflowDefinition> definitions{
+    makeDefinition("a", {{"shared", VariantType::Int, 1, {"shared option"}}}, shared),
+    makeDefinition("b", {{"shared", VariantType::Int, 2, {"shared option"}}}, shared)};
+  REQUIRE_THROWS(defineWorkflow(definitions, {"libA:a", "libB:b"}, 1, const_cast<char**>(args)));
+  // Same option with a different type.
+  definitions[1] = makeDefinition("b", {{"shared", VariantType::Float, 1.f, {"shared option"}}}, shared);
+  REQUIRE_THROWS(defineWorkflow(definitions, {"libA:a", "libB:b"}, 1, const_cast<char**>(args)));
+}
+
+TEST_CASE("TestDuplicateDataProcessor")
+{
+  int shared = 0;
+  char const* args[] = {"test"};
+  std::vector<WorkflowDefinition> definitions{
+    makeDefinition("same", {{"shared", VariantType::Int, 1, {"shared option"}}}, shared),
+    makeDefinition("same", {{"shared", VariantType::Int, 1, {"shared option"}}}, shared)};
+  REQUIRE_THROWS(defineWorkflow(definitions, {"libA:a", "libB:b"}, 1, const_cast<char**>(args)));
+}