diff --git a/Framework/Core/include/Framework/ConfigParamsHelper.h b/Framework/Core/include/Framework/ConfigParamsHelper.h
index 3783cdb374bd1..ceff4f47c4ec1 100644
--- a/Framework/Core/include/Framework/ConfigParamsHelper.h
+++ b/Framework/Core/include/Framework/ConfigParamsHelper.h
@@ -37,6 +37,14 @@ struct ConfigParamsHelper {
                                options_description& options,
                                boost::program_options::options_description const& vetos = options_description());
 
+  /// Maximum length of a default value shown in the help, so that
+  /// an option and its description fit into a typical terminal line
+  static constexpr size_t MaxHelpDefaultLength = 40;
+
+  /// Text to show in the help for the default @a value: values longer than
+  /// MaxHelpDefaultLength are reduced to their beginning and end, separated by "..."
+  static std::string defaultValueForHelp(std::string const& value);
+
   /// Check if option is defined
   static bool hasOption(const std::vector<ConfigParamSpec>& specs, const std::string& optName);
 
@@ -112,7 +120,12 @@ struct ConfigParamsHelper {
       using Type = typename variant_type<V>::type;
       using BoostType = typename std::conditional<V == VariantType::String, std::string, Type>::type;
       auto value = boost::program_options::value<BoostType>();
-      value = value->default_value(spec.defaultValue.get<BoostType>());
+      if constexpr (V == VariantType::String) {
+        auto defaultValue = spec.defaultValue.get<BoostType>();
+        value = value->default_value(defaultValue, defaultValueForHelp(defaultValue));
+      } else {
+        value = value->default_value(spec.defaultValue.get<BoostType>());
+      }
       if constexpr (V == VariantType::Bool) {
         // for bool values we also support the zero_token option to make
         // the option usable as a single switch
@@ -121,11 +134,18 @@ struct ConfigParamsHelper {
       options.add_options()(name, value, help);
     } else if constexpr (isArray<V>() || isArray2D<V>()) {
       auto value = boost::program_options::value<std::string>();
-      value = value->default_value(spec.defaultValue.asString());
+      auto defaultValue = spec.defaultValue.asString();
+      value = value->default_value(defaultValue, defaultValueForHelp(defaultValue));
       if constexpr (V != VariantType::String) {
         value = value->multitoken();
       }
       options.add_options()(name, value, help);
+    } else if constexpr (isLabeledArray<V>()) {
+      // the JSON representation is passed as a single argument
+      auto value = boost::program_options::value<std::string>();
+      auto defaultValue = spec.defaultValue.asString();
+      value = value->default_value(defaultValue, defaultValueForHelp(defaultValue));
+      options.add_options()(name, value, help);
     } else {
       using Type = typename variant_type<V>::type;
       using BoostType = typename std::conditional<V == VariantType::String, std::string, Type>::type;
diff --git a/Framework/Core/include/Framework/Variant.h b/Framework/Core/include/Framework/Variant.h
index c56c0c01ef9fc..e0bbccf560fad 100644
--- a/Framework/Core/include/Framework/Variant.h
+++ b/Framework/Core/include/Framework/Variant.h
@@ -403,6 +403,7 @@ class Variant
     *this = Variant(value, size);
   }
 
+  /// FIXME: set for vector of strings is not used anywhere, why?
   template <typename T>
   void set(std::vector<T>& values)
     requires(std::is_pod_v<T> || std::is_same_v<T, std::string>)
diff --git a/Framework/Core/include/Framework/VariantPropertyTreeHelpers.h b/Framework/Core/include/Framework/VariantPropertyTreeHelpers.h
index 05ab71d39b0e4..afc4a7f989802 100644
--- a/Framework/Core/include/Framework/VariantPropertyTreeHelpers.h
+++ b/Framework/Core/include/Framework/VariantPropertyTreeHelpers.h
@@ -12,7 +12,6 @@
 #define FRAMEWORK_VARIANTPTREEHELPERS_H
 
 #include "Array2D.h"
-#include "Framework/Variant.h"
 #include <boost/property_tree/ptree.hpp>
 
 namespace o2::framework
diff --git a/Framework/Core/src/BoostOptionsRetriever.cxx b/Framework/Core/src/BoostOptionsRetriever.cxx
index fbf56a312cf66..ee559801fdb6e 100644
--- a/Framework/Core/src/BoostOptionsRetriever.cxx
+++ b/Framework/Core/src/BoostOptionsRetriever.cxx
@@ -91,13 +91,13 @@ void BoostOptionsRetriever::update(std::vector<ConfigParamSpec> const& specs,
       case VariantType::Array2DInt:
       case VariantType::Array2DFloat:
       case VariantType::Array2DDouble:
-        options = options(name, bpo::value<std::string>()->default_value(spec.defaultValue.asString()), help);
-        break;
-      case VariantType::Dict:
       case VariantType::LabeledArrayInt:
       case VariantType::LabeledArrayFloat:
       case VariantType::LabeledArrayDouble:
       case VariantType::LabeledArrayString:
+        options = options(name, bpo::value<std::string>()->default_value(spec.defaultValue.asString()), help);
+        break;
+      case VariantType::Dict:
       case VariantType::Unknown:
       case VariantType::Empty:
         break;
diff --git a/Framework/Core/src/ConfigParamsHelper.cxx b/Framework/Core/src/ConfigParamsHelper.cxx
index fc59710fd71a0..77532a3796468 100644
--- a/Framework/Core/src/ConfigParamsHelper.cxx
+++ b/Framework/Core/src/ConfigParamsHelper.cxx
@@ -13,6 +13,7 @@
 #include <boost/program_options.hpp>
 
 #include <string>
+#include <string_view>
 #include <vector>
 #include <iostream>
 
@@ -99,9 +100,17 @@ void ConfigParamsHelper::populateBoostProgramOptions(
         addConfigSpecOption<VariantType::Array2DDouble>(spec, options);
         break;
       case VariantType::LabeledArrayInt:
+        addConfigSpecOption<VariantType::LabeledArrayInt>(spec, options);
+        break;
       case VariantType::LabeledArrayFloat:
+        addConfigSpecOption<VariantType::LabeledArrayFloat>(spec, options);
+        break;
       case VariantType::LabeledArrayDouble:
+        addConfigSpecOption<VariantType::LabeledArrayDouble>(spec, options);
+        break;
       case VariantType::LabeledArrayString:
+        addConfigSpecOption<VariantType::LabeledArrayString>(spec, options);
+        break;
       // FIXME: for  Dict we should probably allow parsing stuff
       //        provided on the command line
       case VariantType::Dict:
@@ -112,6 +121,19 @@ void ConfigParamsHelper::populateBoostProgramOptions(
   }
 }
 
+std::string ConfigParamsHelper::defaultValueForHelp(std::string const& value)
+{
+  constexpr std::string_view ellipsis = "...";
+  if (value.size() <= MaxHelpDefaultLength) {
+    return value;
+  }
+  // Keep more of the beginning, which identifies the value, and the end, which closes it
+  constexpr size_t kept = MaxHelpDefaultLength - ellipsis.size();
+  constexpr size_t tail = kept / 3;
+  constexpr size_t head = kept - tail;
+  return value.substr(0, head) + std::string{ellipsis} + value.substr(value.size() - tail);
+}
+
 /// Check if option is defined
 bool ConfigParamsHelper::hasOption(const std::vector<ConfigParamSpec>& specs, const std::string& optName)
 {
@@ -158,7 +180,7 @@ bool ConfigParamsHelper::dpl2BoostOptions(const std::vector<ConfigParamSpec>& sp
     if (configSpec.type != VariantType::Bool) {
       if (configSpec.defaultValue.type() != VariantType::Empty) {
         options.add_options()(configSpec.name.c_str(),
-                              bpo::value<std::string>()->default_value(defaultValue.str()),
+                              bpo::value<std::string>()->default_value(defaultValue.str(), defaultValueForHelp(defaultValue.str())),
                               configSpec.help.c_str());
       } else {
         options.add_options()(configSpec.name.c_str(),
diff --git a/Framework/Core/src/PropertyTreeHelpers.cxx b/Framework/Core/src/PropertyTreeHelpers.cxx
index 18055edb635b4..dc7e6c2130e96 100644
--- a/Framework/Core/src/PropertyTreeHelpers.cxx
+++ b/Framework/Core/src/PropertyTreeHelpers.cxx
@@ -35,6 +35,32 @@ inline Variant fromString(std::string const& str)
   ss.str(str);
   return VariantJSONHelpers::read<T>(ss);
 }
+
+template <typename T>
+auto replaceLabels(LabeledArray<T>& input, LabeledArray<T>&& spec)
+{
+  if (!input.getLabelsCols().empty() || !input.getLabelsRows().empty()) {
+    return false;
+  }
+  if (spec.getLabelsCols().empty() == false) {
+    input.replaceLabelsCols(spec.getLabelsCols());
+  }
+  if (spec.getLabelsRows().empty() == false) {
+    input.replaceLabelsRows(spec.getLabelsRows());
+  }
+  return true;
+}
+
+/// Special case for a labeled array to restore default labels that were omitted
+template <typename T, VariantType V>
+boost::property_tree::ptree labeledArrayFromStringToBranch(std::string const& str, Variant const& defaultValue)
+{
+  auto v = fromString<V>(str).template get<LabeledArray<T>>();
+  if (defaultValue.type() == V) {
+    replaceLabels(v, defaultValue.get<LabeledArray<T>>());
+  }
+  return labeledArrayToBranch(std::move(v));
+}
 } // namespace
 void PropertyTreeHelpers::populateDefaults(std::vector<ConfigParamSpec> const& schema,
                                            boost::property_tree::ptree& pt,
@@ -233,22 +259,18 @@ void PropertyTreeHelpers::populate(std::vector<ConfigParamSpec> const& schema,
           auto v = fromString<VariantType::Array2DDouble>(vmap[key].as<std::string>());
           pt.put_child(key, array2DToBranch<double>(v.get<Array2D<double>>()));
         } break;
-        case VariantType::LabeledArrayInt: {
-          auto v = fromString<VariantType::LabeledArrayInt>(vmap[key].as<std::string>());
-          pt.put_child(key, labeledArrayToBranch(v.get<LabeledArray<int>>()));
-        } break;
-        case VariantType::LabeledArrayFloat: {
-          auto v = fromString<VariantType::LabeledArrayFloat>(vmap[key].as<std::string>());
-          pt.put_child(key, labeledArrayToBranch(v.get<LabeledArray<float>>()));
-        } break;
-        case VariantType::LabeledArrayDouble: {
-          auto v = fromString<VariantType::LabeledArrayDouble>(vmap[key].as<std::string>());
-          pt.put_child(key, labeledArrayToBranch(v.get<LabeledArray<double>>()));
-        } break;
-        case VariantType::LabeledArrayString: {
-          auto v = fromString<VariantType::LabeledArrayString>(vmap[key].as<std::string>());
-          pt.put_child(key, labeledArrayToBranch(v.get<LabeledArray<std::string>>()));
-        } break;
+        case VariantType::LabeledArrayInt:
+          pt.put_child(key, labeledArrayFromStringToBranch<int, VariantType::LabeledArrayInt>(vmap[key].as<std::string>(), spec.defaultValue));
+          break;
+        case VariantType::LabeledArrayFloat:
+          pt.put_child(key, labeledArrayFromStringToBranch<float, VariantType::LabeledArrayFloat>(vmap[key].as<std::string>(), spec.defaultValue));
+          break;
+        case VariantType::LabeledArrayDouble:
+          pt.put_child(key, labeledArrayFromStringToBranch<double, VariantType::LabeledArrayDouble>(vmap[key].as<std::string>(), spec.defaultValue));
+          break;
+        case VariantType::LabeledArrayString:
+          pt.put_child(key, labeledArrayFromStringToBranch<std::string, VariantType::LabeledArrayString>(vmap[key].as<std::string>(), spec.defaultValue));
+          break;
         case VariantType::Dict:
           pt.put_child(key, vmap[key].as<boost::property_tree::ptree>());
           break;
@@ -272,21 +294,6 @@ void PropertyTreeHelpers::populate(std::vector<ConfigParamSpec> const& schema,
   O2_SIGNPOST_END(configuration, cid, "populate", "Done");
 }
 
-template <typename T>
-auto replaceLabels(LabeledArray<T>& input, LabeledArray<T>&& spec)
-{
-  if (!input.getLabelsCols().empty() || !input.getLabelsRows().empty()) {
-    return false;
-  }
-  if (spec.getLabelsCols().empty() == false) {
-    input.replaceLabelsCols(spec.getLabelsCols());
-  }
-  if (spec.getLabelsRows().empty() == false) {
-    input.replaceLabelsRows(spec.getLabelsRows());
-  }
-  return true;
-}
-
 void PropertyTreeHelpers::populate(std::vector<ConfigParamSpec> const& schema,
                                    boost::property_tree::ptree& pt,
                                    boost::property_tree::ptree const& in,
diff --git a/Framework/Core/src/Variant.cxx b/Framework/Core/src/Variant.cxx
index 35d20f85ba919..ad89e22a3bf39 100644
--- a/Framework/Core/src/Variant.cxx
+++ b/Framework/Core/src/Variant.cxx
@@ -66,6 +66,10 @@ std::ostream& operator<<(std::ostream& oss, Variant const& val)
     case VariantType::Array2DInt:
     case VariantType::Array2DFloat:
     case VariantType::Array2DDouble:
+    case VariantType::LabeledArrayInt:
+    case VariantType::LabeledArrayFloat:
+    case VariantType::LabeledArrayDouble:
+    case VariantType::LabeledArrayString:
       VariantJSONHelpers::write(oss, val);
       break;
     case VariantType::Empty:
diff --git a/Framework/Core/test/test_BoostOptionsRetriever.cxx b/Framework/Core/test/test_BoostOptionsRetriever.cxx
index d2a40ea36b4bd..33869f00d3088 100644
--- a/Framework/Core/test/test_BoostOptionsRetriever.cxx
+++ b/Framework/Core/test/test_BoostOptionsRetriever.cxx
@@ -11,9 +11,14 @@
 
 #include "Framework/ConfigParamsHelper.h"
 #include "Framework/ConfigParamSpec.h"
+#include "Framework/BoostOptionsRetriever.h"
+#include "Framework/ConfigParamRegistry.h"
+#include "Framework/ConfigParamStore.h"
+#include "Framework/DataProcessorSpec.h"
 #include <boost/program_options.hpp>
 #include <boost/program_options/parsers.hpp>
 #include <catch_amalgamated.hpp>
+#include <sstream>
 #include <vector>
 
 using namespace o2::framework;
@@ -70,3 +75,133 @@ TEST_CASE("TrivialBoostOptionsRetrieverTest")
   REQUIRE(vm["someFloat"].as<float>() == 0.5);
   REQUIRE(vm["someDouble"].as<double>() == 0.5);
 }
+
+namespace
+{
+constexpr char const* fullLabeledJSON = R"({"labels_rows":["a","b"],"labels_cols":["x","y"],"values":[[5,6],[7,8]]})";
+
+LabeledArray<int> defaultLabeledArray()
+{
+  int m[2][2] = {{1, 2}, {3, 4}};
+  return LabeledArray<int>{&m[0][0], 2, 2, {"r1", "r2"}, {"c1", "c2"}};
+}
+
+std::unique_ptr<ConfigParamRegistry> registryFromCommandLine(std::vector<ConfigParamSpec> const& specs, std::vector<char const*> args)
+{
+  args.insert(args.begin(), "test");
+  std::vector<std::unique_ptr<ParamRetriever>> retrievers;
+  retrievers.emplace_back(std::make_unique<BoostOptionsRetriever>(true, args.size(), const_cast<char**>(args.data())));
+  auto store = std::make_unique<ConfigParamStore>(specs, std::move(retrievers));
+  store->preload();
+  store->activate();
+  return std::make_unique<ConfigParamRegistry>(std::move(store));
+}
+} // namespace
+
+TEST_CASE("LabeledArrayBoostOptionsTest")
+{
+  namespace bpo = boost::program_options;
+  auto specs = std::vector<ConfigParamSpec>{
+    {"someLabeledArray", VariantType::LabeledArrayInt, defaultLabeledArray(), {"some labeled array option"}}};
+
+  // the option is registered as a string holding the JSON representation
+  bpo::options_description opts;
+  ConfigParamsHelper::populateBoostProgramOptions(opts, specs);
+  const char* args[] = {"test", "--someLabeledArray", fullLabeledJSON};
+  bpo::variables_map vm;
+  bpo::store(parse_command_line(sizeof(args) / sizeof(char*), args, opts), vm);
+  bpo::notify(vm);
+  REQUIRE(vm["someLabeledArray"].as<std::string>() == fullLabeledJSON);
+
+  // the default is the JSON representation of the default value
+  bpo::variables_map vmDefault;
+  const char* noArgs[] = {"test"};
+  bpo::store(parse_command_line(1, noArgs, opts), vmDefault);
+  REQUIRE(vmDefault["someLabeledArray"].as<std::string>() == specs[0].defaultValue.asString());
+}
+
+TEST_CASE("LabeledArrayBoostOptionsRetrieverTest")
+{
+  auto specs = std::vector<ConfigParamSpec>{
+    {"someLabeledArray", VariantType::LabeledArrayInt, defaultLabeledArray(), {"some labeled array option"}}};
+
+  // full JSON on the command line, its labels are kept
+  auto registry = registryFromCommandLine(specs, {"--someLabeledArray", fullLabeledJSON});
+  auto la = registry->get<LabeledArray<int>>("someLabeledArray");
+  REQUIRE(la.getLabelsRows() == std::vector<std::string>{"a", "b"});
+  REQUIRE(la.getLabelsCols() == std::vector<std::string>{"x", "y"});
+  REQUIRE(la.get("b", "y") == 8);
+
+  // absent from the command line: the default value
+  registry = registryFromCommandLine(specs, {});
+  la = registry->get<LabeledArray<int>>("someLabeledArray");
+  REQUIRE(la.get("r2", "c2") == 4);
+
+  // only values on the command line: the default labels are used
+  registry = registryFromCommandLine(specs, {"--someLabeledArray", R"({"values":[[5,6],[7,8]]})"});
+  la = registry->get<LabeledArray<int>>("someLabeledArray");
+  REQUIRE(la.getLabelsRows() == std::vector<std::string>{"r1", "r2"});
+  REQUIRE(la.getLabelsCols() == std::vector<std::string>{"c1", "c2"});
+  REQUIRE(la.get("r2", "c1") == 7);
+
+  // values which do not match the default labels
+  REQUIRE_THROWS(registryFromCommandLine(specs, {"--someLabeledArray", R"({"values":[[5,6,7]]})"}));
+}
+
+TEST_CASE("DefaultValueForHelpTest")
+{
+  auto const max = ConfigParamsHelper::MaxHelpDefaultLength;
+  REQUIRE(ConfigParamsHelper::defaultValueForHelp("") == "");
+  REQUIRE(ConfigParamsHelper::defaultValueForHelp("short") == "short");
+  std::string atLimit(max, 'x');
+  REQUIRE(ConfigParamsHelper::defaultValueForHelp(atLimit) == atLimit);
+
+  std::string longValue = std::string("BEGIN") + std::string(100, '-') + "END";
+  auto shown = ConfigParamsHelper::defaultValueForHelp(longValue);
+  REQUIRE(shown.size() == max);
+  REQUIRE(shown.starts_with("BEGIN"));
+  REQUIRE(shown.ends_with("END"));
+  REQUIRE(shown.find("...") != std::string::npos);
+  REQUIRE(ConfigParamsHelper::defaultValueForHelp(std::string(max + 1, 'x')).size() == max);
+}
+
+TEST_CASE("LongDefaultInHelpTest")
+{
+  namespace bpo = boost::program_options;
+  std::vector<int> values(30, 12345);
+  std::vector<std::string> rows{"row"};
+  std::vector<std::string> cols;
+  for (auto i = 0U; i < values.size(); ++i) {
+    cols.push_back("column" + std::to_string(i));
+  }
+  LabeledArray<int> la{values.data(), 1, static_cast<uint32_t>(values.size()), rows, cols};
+  auto workflowOptions = std::vector<ConfigParamSpec>{
+    {"longLabeledArray", VariantType::LabeledArrayInt, la, {"a labeled array option with a long default"}}};
+  auto full = workflowOptions[0].defaultValue.asString();
+  REQUIRE(full.size() > ConfigParamsHelper::MaxHelpDefaultLength);
+
+  // the help shows the abbreviated default only
+  auto description = ConfigParamsHelper::prepareOptionDescriptions(std::vector<DataProcessorSpec>{}, workflowOptions);
+  std::stringstream help;
+  help << description;
+  REQUIRE(help.str().find(ConfigParamsHelper::defaultValueForHelp(full)) != std::string::npos);
+  REQUIRE(help.str().find(full) == std::string::npos);
+
+  // the default value used when parsing is still the full one
+  bpo::options_description forwarded;
+  ConfigParamsHelper::dpl2BoostOptions(workflowOptions, forwarded);
+  const char* noArgs[] = {"test"};
+  bpo::variables_map vm;
+  bpo::store(parse_command_line(1, noArgs, forwarded), vm);
+  REQUIRE(vm["longLabeledArray"].as<std::string>() == full);
+
+  // also for the options registered for the devices
+  bpo::options_description deviceOptions;
+  ConfigParamsHelper::populateBoostProgramOptions(deviceOptions, workflowOptions);
+  std::stringstream deviceHelp;
+  deviceHelp << deviceOptions;
+  REQUIRE(deviceHelp.str().find(full) == std::string::npos);
+  bpo::variables_map deviceVm;
+  bpo::store(parse_command_line(1, noArgs, deviceOptions), deviceVm);
+  REQUIRE(deviceVm["longLabeledArray"].as<std::string>() == full);
+}
diff --git a/Framework/Core/test/test_DeviceSpecHelpers.cxx b/Framework/Core/test/test_DeviceSpecHelpers.cxx
index 4184be848c5ec..d689e7a2765c4 100644
--- a/Framework/Core/test/test_DeviceSpecHelpers.cxx
+++ b/Framework/Core/test/test_DeviceSpecHelpers.cxx
@@ -101,12 +101,16 @@ void check(const std::vector<std::string>& arguments,
 
 TEST_CASE("test_prepareArguments")
 {
+  int lm[1][2] = {{1, 2}};
   std::vector<ConfigParamSpec> workflowOptions{
-    {"foo", VariantType::String, "bar", {"the famous foo option"}},
-    {"depth", VariantType::Int, 1, {"number of processors"}},
+    {"foo", VariantType::String, "bar", {"charlie foxtrot"}},
+    {"depth", VariantType::Int, 1, {"height"}},
+    {"labeled", VariantType::LabeledArrayInt, LabeledArray<int>{&lm[0][0], 1, 2, {"r"}, {"c1", "c2"}}, {"a labeled array"}},
   };
+  std::string labeledDefault = R"({"labels_rows":["r"],"labels_cols":["c1","c2"],"values":[[1,2]]})";
+  std::string labeledOther = R"({"labels_rows":["r"],"labels_cols":["c1","c2"],"values":[[3,4]]})";
 
-  auto algorithm = [](ProcessingContext& ctx) {};
+  auto algorithm = [](ProcessingContext& /*ctx*/) {};
 
   WorkflowSpec workflow{
     {"processor0",
@@ -177,6 +181,14 @@ TEST_CASE("test_prepareArguments")
   matrix["processor0"] = {{"--depth", "2"}, {"--foo", "bar"}, {"--mode", "silly"}};
   matrix["processor1"] = {{"--depth", "2"}, {"--foo", "bar"}, {"--mode", "default"}};
   check({"--depth", "2", "--processor0", "--mode silly"}, workflowOptions, deviceSpecs, matrix);
+
+  // a LabeledArray workflow option is forwarded as a single JSON argument, defaulted or set
+  matrix["processor0"] = {{"--depth", "1"}, {"--labeled", labeledDefault}};
+  matrix["processor1"] = matrix["processor0"];
+  check({}, workflowOptions, deviceSpecs, matrix);
+  matrix["processor0"] = {{"--depth", "1"}, {"--labeled", labeledOther}};
+  matrix["processor1"] = matrix["processor0"];
+  check({"--labeled", labeledOther}, workflowOptions, deviceSpecs, matrix);
 }
 
 TEST_CASE("CheckOptionReworking")
diff --git a/Framework/Core/test/test_FairMQOptionsRetriever.cxx b/Framework/Core/test/test_FairMQOptionsRetriever.cxx
index 11f8acd7534fa..8cf6870e469b5 100644
--- a/Framework/Core/test/test_FairMQOptionsRetriever.cxx
+++ b/Framework/Core/test/test_FairMQOptionsRetriever.cxx
@@ -13,6 +13,8 @@
 #include <boost/program_options.hpp>
 #include "Framework/FairOptionsRetriever.h"
 #include "Framework/ConfigParamStore.h"
+#include "Framework/ConfigParamsHelper.h"
+#include "Framework/VariantPropertyTreeHelpers.h"
 #include <fairmq/ProgOptions.h>
 #include <boost/property_tree/ptree.hpp>
 
@@ -130,3 +132,44 @@ TEST_CASE("TestOptionsDefaults")
   REQUIRE(store.provenance("aNested.float") == "fairmq");
   REQUIRE(store.provenance("aNested.double") == "default");
 }
+
+TEST_CASE("TestFairMQOptionsRetrieverLabeledArray")
+{
+  int m[2][2] = {{1, 2}, {3, 4}};
+  std::vector<ConfigParamSpec> specs{
+    ConfigParamSpec{"aLabeledArray", VariantType::LabeledArrayInt, LabeledArray<int>{&m[0][0], 2, 2, {"r1", "r2"}, {"c1", "c2"}}, {"a labeled array option"}},
+  };
+  // options registered as for a device
+  bpo::options_description testOptions("Test options");
+  ConfigParamsHelper::populateBoostProgramOptions(testOptions, specs);
+
+  auto storeFromCommandLine = [&](std::vector<std::string> const& args) {
+    auto options = std::make_unique<fair::mq::ProgOptions>();
+    options->AddToCmdLineOptions(testOptions);
+    options->ParseAll(args, true);
+    std::vector<std::unique_ptr<ParamRetriever>> retrievers;
+    retrievers.emplace_back(std::make_unique<FairOptionsRetriever>(options.get()));
+    auto store = std::make_unique<ConfigParamStore>(specs, std::move(retrievers));
+    store->preload();
+    store->activate();
+    return labeledArrayFromBranch<int>(store->store().get_child("aLabeledArray"));
+  };
+
+  // the full JSON, as forwarded by the driver
+  auto la = storeFromCommandLine({"cmd", "--aLabeledArray", R"({"labels_rows":["a","b"],"labels_cols":["x","y"],"values":[[5,6],[7,8]]})"});
+  REQUIRE(la.getLabelsRows() == std::vector<std::string>{"a", "b"});
+  REQUIRE(la.getLabelsCols() == std::vector<std::string>{"x", "y"});
+  REQUIRE(la.get("a", "y") == 6);
+
+  // no argument: the default
+  la = storeFromCommandLine({"cmd"});
+  REQUIRE(la.get("r1", "c2") == 2);
+
+  // only values: the default labels are used
+  la = storeFromCommandLine({"cmd", "--aLabeledArray", R"({"values":[[5,6],[7,8]]})"});
+  REQUIRE(la.getLabelsRows() == std::vector<std::string>{"r1", "r2"});
+  REQUIRE(la.get("r2", "c2") == 8);
+
+  // values which do not match the default labels
+  REQUIRE_THROWS(storeFromCommandLine({"cmd", "--aLabeledArray", R"({"values":[[5,6,7]]})"}));
+}
diff --git a/Framework/Core/test/test_Variants.cxx b/Framework/Core/test/test_Variants.cxx
index 244dd3c9359c5..77f6a7d2918e3 100644
--- a/Framework/Core/test/test_Variants.cxx
+++ b/Framework/Core/test/test_Variants.cxx
@@ -574,3 +574,47 @@ TEST_CASE("VariantFromVectorTest")
     REQUIRE(read.get<double*>()[i] == vd[i]);
   }
 }
+
+namespace
+{
+template <VariantType V, typename T>
+void checkLabeledArrayStringRoundTrip(LabeledArray<T> const& la)
+{
+  Variant v(la);
+  auto str = v.asString();
+  REQUIRE(str.find("undefined") == std::string::npos);
+  std::stringstream is(str);
+  auto vr = VariantJSONHelpers::read<V>(is);
+  REQUIRE(vr.type() == V);
+  auto lar = vr.template get<LabeledArray<T>>();
+  REQUIRE(lar.rows() == la.rows());
+  REQUIRE(lar.cols() == la.cols());
+  REQUIRE(lar.getLabelsRows() == la.getLabelsRows());
+  REQUIRE(lar.getLabelsCols() == la.getLabelsCols());
+  for (auto i = 0U; i < la.rows(); ++i) {
+    for (auto j = 0U; j < la.cols(); ++j) {
+      REQUIRE(lar.get(i, j) == la.get(i, j));
+    }
+  }
+}
+} // namespace
+
+TEST_CASE("LabeledArrayAsStringTest")
+{
+  int mi[2][2] = {{1, 2}, {3, 4}};
+  float mf[2][3] = {{0.5, 0.25, 0.125}, {1, 2, 3}};
+  double md[1][2] = {{1e-3, 1e10}};
+  std::string ms[2][1] = {{"a"}, {"b c"}};
+
+  checkLabeledArrayStringRoundTrip<VariantType::LabeledArrayInt>(LabeledArray<int>{&mi[0][0], 2, 2, {"r1", "r2"}, {"c1", "c2"}});
+  checkLabeledArrayStringRoundTrip<VariantType::LabeledArrayFloat>(LabeledArray<float>{&mf[0][0], 2, 3, {"r1", "r2"}, {"c1", "c2", "c3"}});
+  checkLabeledArrayStringRoundTrip<VariantType::LabeledArrayDouble>(LabeledArray<double>{&md[0][0], 1, 2, {"r1"}, {"c1", "c2"}});
+  checkLabeledArrayStringRoundTrip<VariantType::LabeledArrayString>(LabeledArray<std::string>{&ms[0][0], 2, 1, {"r1", "r2"}, {"c1"}});
+  // without labels
+  checkLabeledArrayStringRoundTrip<VariantType::LabeledArrayInt>(LabeledArray<int>{&mi[0][0], 2, 2});
+  // labels which need escaping in JSON
+  checkLabeledArrayStringRoundTrip<VariantType::LabeledArrayFloat>(LabeledArray<float>{&mf[0][0], 2, 3, {"row \"one\"", "row\\two"}, {"c 1", "c,2", "c:3"}});
+
+  Variant v(LabeledArray<int>{&mi[0][0], 2, 2, {"r1", "r2"}, {"c1", "c2"}});
+  REQUIRE(v.asString() == R"({"labels_rows":["r1","r2"],"labels_cols":["c1","c2"],"values":[[1,2],[3,4]]})");
+}
diff --git a/Framework/Core/test/test_WorkflowSerialization.cxx b/Framework/Core/test/test_WorkflowSerialization.cxx
index 791c40c326733..5ffbbcda3df57 100644
--- a/Framework/Core/test/test_WorkflowSerialization.cxx
+++ b/Framework/Core/test/test_WorkflowSerialization.cxx
@@ -18,6 +18,8 @@ using namespace o2::framework;
 TEST_CASE("TestVerifyWorkflowSerialization")
 {
   using namespace o2::framework;
+  int lm[2][2] = {{1, 2}, {3, 4}};
+  LabeledArray<int> labeled{&lm[0][0], 2, 2, {"r1", "r2"}, {"c1", "c2"}};
   WorkflowSpec w0{                       //
                   DataProcessorSpec{"A", //
                                     {InputSpec{"foo", "A", "COLLISIONCONTEXT", 1, Lifetime::Condition, {
@@ -25,34 +27,35 @@ TEST_CASE("TestVerifyWorkflowSerialization")
                                                                                                          ConfigParamSpec{"bUrl", VariantType::String, "foo/foo", {"Another InputSpec option"}}, //
                                                                                                        }}},                                                                                     //
                                     {OutputSpec{{"bar"}, "C", "D", 2, Lifetime::Timeframe}},                                                                                                    //
-                                    AlgorithmSpec{[](ProcessingContext& ctx) {}},                                                                                                               //
+                                    AlgorithmSpec{[](ProcessingContext& /*ctx*/) {}},                                                                                                           //
                                     {                                                                                                                                                           //
                                      ConfigParamSpec{"aInt", VariantType::Int, 0, {"An Int"}},                                                                                                  //
                                      ConfigParamSpec{"aFloat", VariantType::Float, 1.3, {"A Float"}},                                                                                           //
                                      ConfigParamSpec{"aBool", VariantType::Bool, true, {"A Bool"}},                                                                                             //
-                                     ConfigParamSpec{"aString", VariantType::String, "some string", {"A String"}}}},                                                                            //                                                                                                    //
+                                     ConfigParamSpec{"aString", VariantType::String, "some string", {"A String"}},                                                                              //
+                                     ConfigParamSpec{"aLabeledArray", VariantType::LabeledArrayInt, labeled, {"A LabeledArray"}}}},                                                             //                                                                                                    //
                   DataProcessorSpec{"B",                                                                                                                                                        //
                                     {InputSpec{"foo", "C", "D"}},                                                                                                                               //
                                     {                                                                                                                                                           //
                                      OutputSpec{{"bar1"}, "E", "F", 0},                                                                                                                         //
                                      OutputSpec{{"bar2"}, "E", "F", 1}},                                                                                                                        //
-                                    AlgorithmSpec{[](ProcessingContext& ctx) {}},                                                                                                               //
+                                    AlgorithmSpec{[](ProcessingContext& /*ctx*/) {}},                                                                                                           //
                                     {}},                                                                                                                                                        //
                   DataProcessorSpec{"C", {},                                                                                                                                                    //
                                     {                                                                                                                                                           //
                                      OutputSpec{{"bar"}, "G", "H"}},                                                                                                                            //
-                                    AlgorithmSpec{[](ProcessingContext& ctx) {}},                                                                                                               //
+                                    AlgorithmSpec{[](ProcessingContext& /*ctx*/) {}},                                                                                                           //
                                     {}},                                                                                                                                                        //
                   DataProcessorSpec{"D", {InputSpec{"foo", {"C", "D"}}},                                                                                                                        //
                                     {OutputSpec{{"bar"}, {"I", "L"}}},                                                                                                                          //
-                                    AlgorithmSpec{[](ProcessingContext& ctx) {}},                                                                                                               //
+                                    AlgorithmSpec{[](ProcessingContext& /*ctx*/) {}},                                                                                                           //
                                     {},                                                                                                                                                         //
                                     CommonServices::defaultServices(),                                                                                                                          //
                                     {{"label a"}, {"label \"b\""}},
                                     {{"key1", "v\"al'1"}, {"", "val2"}, {"key3", ""}, {"", ""}}}};
 
   std::vector<DataProcessorInfo> dataProcessorInfoOut{
-    {.name = "A", .executable = "test_Framework_test_SerializationWorkflow", .cmdLineArgs = {"foo"}, .workflowOptions = {ConfigParamSpec{"aBool", VariantType::Bool, true, {"A Bool"}}}},
+    {.name = "A", .executable = "test_Framework_test_SerializationWorkflow", .cmdLineArgs = {"foo"}, .workflowOptions = {ConfigParamSpec{"aBool", VariantType::Bool, true, {"A Bool"}}, ConfigParamSpec{"aLabeledArray", VariantType::LabeledArrayInt, labeled, {"A LabeledArray"}}}},
     {.name = "B", .executable = "test_Framework_test_SerializationWorkflow", .cmdLineArgs = {"b-bar", "bfoof", "fbdbfaso"}},
     {.name = "C", .executable = "test_Framework_test_SerializationWorkflow"},
     {.name = "D", .executable = "test_Framework_test_SerializationWorkflow"},
@@ -80,6 +83,19 @@ TEST_CASE("TestVerifyWorkflowSerialization")
 
   // also check if the conversion to ConcreteDataMatcher is working at import
   REQUIRE(std::get_if<ConcreteDataMatcher>(&w1[0].inputs[0].matcher) != nullptr);
+
+  // LabeledArray options survive the round trip, both as processor and as workflow options
+  auto checkLabeled = [&](ConfigParamSpec const& spec) {
+    REQUIRE(spec.name == "aLabeledArray");
+    REQUIRE(spec.type == VariantType::LabeledArrayInt);
+    auto la = spec.defaultValue.get<LabeledArray<int>>();
+    REQUIRE(la.getLabelsRows() == labeled.getLabelsRows());
+    REQUIRE(la.getLabelsCols() == labeled.getLabelsCols());
+    REQUIRE(la.get("r2", "c1") == 3);
+  };
+  checkLabeled(w1[0].options.back());
+  REQUIRE(dataProcessorInfoIn[0].workflowOptions.size() == 2);
+  checkLabeled(dataProcessorInfoIn[0].workflowOptions.back());
 }
 
 /// Test a workflow with a single data processor with a single input