diff --git a/demo/include/demo/pacman_agent.hpp b/demo/include/demo/pacman_agent.hpp
index 2c083c25..2524e3e5 100644
--- a/demo/include/demo/pacman_agent.hpp
+++ b/demo/include/demo/pacman_agent.hpp
@@ -46,12 +46,10 @@ class PacmanAgent {
         moveRandomlyBehavior_ = std::make_shared<MoveRandomlyBehavior>(parameters_.moveRandomlyBehavior);
         stayInPlaceBehavior_ = std::make_shared<StayInPlaceBehavior>();
 
-        eatDotsArbitrator_ = std::make_shared<CostArbitrator>("EatDots", verifier_);
-        costEstimator_ = std::make_shared<CostEstimator>(parameters_.costEstimator);
-        eatDotsArbitrator_->addOption(
-            changeDotClusterBehavior_, CostArbitrator::Option::Flags::Interruptable, costEstimator_);
-        eatDotsArbitrator_->addOption(
-            eatClosestDotBehavior_, CostArbitrator::Option::Flags::Interruptable, costEstimator_);
+        CostEstimator::Ptr costEstimator = std::make_shared<CostEstimator>(parameters_.costEstimator);
+        eatDotsArbitrator_ = std::make_shared<CostArbitrator>("EatDots", costEstimator, verifier_);
+        eatDotsArbitrator_->addOption(changeDotClusterBehavior_, CostArbitrator::Option::Flags::Interruptable);
+        eatDotsArbitrator_->addOption(eatClosestDotBehavior_, CostArbitrator::Option::Flags::Interruptable);
 
         rootArbitrator_ = std::make_shared<PriorityArbitrator>("Pac-Man", verifier_);
         rootArbitrator_->addOption(chaseGhostBehavior_, PriorityArbitrator::Option::Flags::Interruptable);
@@ -98,7 +96,6 @@ class PacmanAgent {
     PriorityArbitrator::Ptr rootArbitrator_;
     CostArbitrator::Ptr eatDotsArbitrator_;
 
-    CostEstimator::Ptr costEstimator_;
     Verifier::Ptr verifier_;
 };
 
diff --git a/docs/tasks/4_cost_arbitration.md b/docs/tasks/4_cost_arbitration.md
index 5704f618..114d4ce2 100644
--- a/docs/tasks/4_cost_arbitration.md
+++ b/docs/tasks/4_cost_arbitration.md
@@ -34,9 +34,9 @@ Finish the implementation of the `CostEstimator` and replace the random arbitrat
 - Run the unit tests and note that some of the `CostEstimator` tests are failing
 - In `cost_estimator.cpp`, fill in the blanks to compute `nDots` and `nCells`.
 - Compile and run the unit tests for the `CostEstimator` to verify that your implementation is correct.
-- Add an instance of the `CostEstimator` to the `PacmanAgent` class and initialize it in the constructor.
+- Create an instance of the `CostEstimator` in the `PacmanAgent` constructor.
   Don't forget to include the necessary headers and extend the parameter struct with the parameters for the `CostEstimator`.
-- Replace the random arbitrator with a cost arbitrator in the `PacmanAgent` class. Pass the `CostEstimator` instance to the `addOption()` method.
+- Replace the random arbitrator with a cost arbitrator in the `PacmanAgent` class passing the `CostEstimator` instance to the constructor.
 
 ## Solution
 
@@ -86,12 +86,10 @@ To keep things tidy and consistent, add an alias definition analogous to the exi
 using CostArbitrator = arbitration_graphs::CostArbitrator<EnvironmentModel, Command>;
 ```
 
-Change the type of the `eatDotsArbitrator_` member in the `PacmanAgent` class to `CostArbitrator` and add an instance of the `CostEstimator`:
+Change the type of the `eatDotsArbitrator_` member in the `PacmanAgent` class to `CostArbitrator`:
 ```cpp
 private:
     CostArbitrator::Ptr eatDotsArbitrator_;
-
-    CostEstimator::Ptr costEstimator_;
 ```
 
 Extend the `Parameters` struct to contain the parameters for the `CostEstimator`:
@@ -107,7 +105,7 @@ struct Parameters {
 ```
 
 As always, the magic happens in the constructor of the `PacmanAgent` class.
-Instantiate the cost estimator and pass it in the `addOption` calls:
+Instantiate the cost estimator and pass it to the new cost arbitrator:
 ```cpp
 explicit PacmanAgent(const entt::Game& game) : parameters_{}, environmentModel_{game} {
     avoidGhostBehavior_ = std::make_shared<AvoidGhostBehavior>(parameters_.avoidGhostBehavior);
@@ -116,16 +114,13 @@ explicit PacmanAgent(const entt::Game& game) : parameters_{}, environmentModel_{
     eatClosestDotBehavior_ = std::make_shared<EatClosestDotBehavior>();
     moveRandomlyBehavior_ = std::make_shared<MoveRandomlyBehavior>(parameters_.moveRandomlyBehavior);
 
-    // This is now a cost arbitrator
-    eatDotsArbitrator_ = std::make_shared<CostArbitrator>("EatDots");
     // Construct the cost estimator
-    costEstimator_ = std::make_shared<CostEstimator>(parameters_.costEstimator);
-    // Add the ChangeDotCluster and EatClosestDot behavior components as options to the
-    // cost arbitrator while also passing the cost estimator
-    eatDotsArbitrator_->addOption(
-        changeDotClusterBehavior_, CostArbitrator::Option::Flags::Interruptable, costEstimator_);
-    eatDotsArbitrator_->addOption(
-        eatClosestDotBehavior_, CostArbitrator::Option::Flags::Interruptable, costEstimator_);
+    CostEstimator::Ptr costEstimator = std::make_shared<CostEstimator>(parameters_.costEstimator);
+    // This is now a cost arbitrator using the cost estimator
+    eatDotsArbitrator_ = std::make_shared<CostArbitrator>("EatDots", costEstimator);
+    // Add the ChangeDotCluster and EatClosestDot behavior components as options to the cost arbitrator
+    eatDotsArbitrator_->addOption(changeDotClusterBehavior_, CostArbitrator::Option::Flags::Interruptable);
+    eatDotsArbitrator_->addOption(eatClosestDotBehavior_, CostArbitrator::Option::Flags::Interruptable);
 
     rootArbitrator_ = std::make_shared<PriorityArbitrator>("Pac-Man");
     rootArbitrator_->addOption(chaseGhostBehavior_, PriorityArbitrator::Option::Flags::Interruptable);
diff --git a/docs/tasks/5_verification.md b/docs/tasks/5_verification.md
index a79ea98b..9b2a08f1 100644
--- a/docs/tasks/5_verification.md
+++ b/docs/tasks/5_verification.md
@@ -116,12 +116,10 @@ explicit PacmanAgent(const entt::Game& game) : parameters_{}, environmentModel_{
     stayInPlaceBehavior_ = std::make_shared<StayInPlaceBehavior>();
 
     // Pass the verifier instance to the cost arbitrator
-    eatDotsArbitrator_ = std::make_shared<CostArbitrator>("EatDots", verifier_);
-    costEstimator_ = std::make_shared<CostEstimator>(parameters_.costEstimator);
-    eatDotsArbitrator_->addOption(
-        changeDotClusterBehavior_, CostArbitrator::Option::Flags::Interruptable, costEstimator_);
-    eatDotsArbitrator_->addOption(
-        eatClosestDotBehavior_, CostArbitrator::Option::Flags::Interruptable, costEstimator_);
+    CostEstimator::Ptr costEstimator = std::make_shared<CostEstimator>(parameters_.costEstimator);
+    eatDotsArbitrator_ = std::make_shared<CostArbitrator>("EatDots", costEstimator, verifier_);
+    eatDotsArbitrator_->addOption(changeDotClusterBehavior_, CostArbitrator::Option::Flags::Interruptable);
+    eatDotsArbitrator_->addOption(eatClosestDotBehavior_, CostArbitrator::Option::Flags::Interruptable);
 
     // Pass the verifier instance to the priority arbitrator
     rootArbitrator_ = std::make_shared<PriorityArbitrator>("Pac-Man", verifier_);
diff --git a/include/arbitration_graphs/cost_arbitrator.hpp b/include/arbitration_graphs/cost_arbitrator.hpp
index c182c5d4..6bee6e3b 100644
--- a/include/arbitration_graphs/cost_arbitrator.hpp
+++ b/include/arbitration_graphs/cost_arbitrator.hpp
@@ -1,15 +1,28 @@
 #pragma once
 
 #include <memory>
+#include <numeric>
 #include <optional>
 
+#include <util_caching/cache.hpp>
 #include <yaml-cpp/yaml.h>
 
 #include "arbitrator.hpp"
+#include "exceptions.hpp"
+#include "types.hpp"
 
 
 namespace arbitration_graphs {
 
+/**
+ * \brief Interface for estimating the cost of a single command.
+ *
+ * A CostEstimator computes a scalar cost value for a single command given
+ * the current environment state and execution context.
+ *
+ * The CostArbitrator will use the cost estimates to sort the behavior options
+ * and select the one with the lowest cost.
+ */
 template <typename EnvironmentModelT, typename SubCommandT>
 struct CostEstimator {
     using Ptr = std::shared_ptr<CostEstimator>;
@@ -21,6 +34,84 @@ struct CostEstimator {
                                 bool isActive) = 0;
 };
 
+/**
+ * \brief Interface for estimating costs for multiple commands in a single batch.
+ *
+ * An alternative to the per-option CostEstimator for more advanced use cases.
+ * A BatchCostEstimator computes cost values for multiple commands at once.
+ * This interface enables implementations to exploit shared computation,
+ * vectorization, or global context across candidates.
+ *
+ * \note The returned cost vector must have the same order and size as the input candidates vector.
+ */
+template <typename EnvironmentModelT, typename SubCommandT>
+struct BatchCostEstimator {
+    using Ptr = std::shared_ptr<BatchCostEstimator>;
+    using ConstPtr = std::shared_ptr<const BatchCostEstimator>;
+
+    struct Candidate {
+        SubCommandT command;
+        bool isActive;
+    };
+
+    virtual std::vector<double> estimateCosts(const Time& time,
+                                              const EnvironmentModelT& environmentModel,
+                                              const std::vector<Candidate>& candidates) = 0;
+};
+
+template <typename EnvironmentModelT, typename SubCommandT>
+class PerOptionToBatchAdapter : public BatchCostEstimator<EnvironmentModelT, SubCommandT> {
+public:
+    using CandidateT = typename BatchCostEstimator<EnvironmentModelT, SubCommandT>::Candidate;
+    using CostEstimatorT = CostEstimator<EnvironmentModelT, SubCommandT>;
+    explicit PerOptionToBatchAdapter(typename CostEstimatorT::Ptr perOptionEstimator)
+            : perOptionEstimator_(std::move(perOptionEstimator)) {
+    }
+    std::vector<double> estimateCosts(const Time& time,
+                                      const EnvironmentModelT& environmentModel,
+                                      const std::vector<CandidateT>& candidates) override {
+        std::vector<double> costs;
+        costs.reserve(candidates.size());
+        for (const auto& candidate : candidates) {
+            costs.push_back(
+                perOptionEstimator_->estimateCost(time, environmentModel, candidate.command, candidate.isActive));
+        }
+        return costs;
+    }
+
+private:
+    typename CostEstimatorT::Ptr perOptionEstimator_;
+};
+
+/**
+ * \brief The PlaceboCostEstimator is a dummy estimator assigning monotonically increasing costs.
+ *
+ * This estimator assigns costs purely based on the candidate order:
+ * the first candidate gets cost 0.0, the second 1.0, and so on.
+ *
+ * As a result, the CostArbitrator effectively degrades into a
+ * priority-based arbitrator where earlier options always win over
+ * later ones, regardless of the command or environment state.
+ *
+ * \warning Users will very likely *not* want to rely on this default
+ *          in real applications. It is mainly provided to keep the CostArbitrator
+ *          constructor analogous to other arbitrators.
+ */
+template <typename EnvironmentModelT, typename SubCommandT>
+class PlaceboCostEstimator : public BatchCostEstimator<EnvironmentModelT, SubCommandT> {
+public:
+    using CandidateT = typename BatchCostEstimator<EnvironmentModelT, SubCommandT>::Candidate;
+
+    std::vector<double> estimateCosts(const Time& /*time*/,
+                                      const EnvironmentModelT& /*environmentModel*/,
+                                      const std::vector<CandidateT>& candidates) override {
+        std::vector<double> costs(candidates.size());
+        std::iota(costs.begin(), costs.end(), 0.0);
+        return costs;
+    }
+};
+
+
 template <typename EnvironmentModelT, typename CommandT, typename SubCommandT = CommandT>
 class CostArbitrator : public Arbitrator<EnvironmentModelT, CommandT, SubCommandT> {
 public:
@@ -29,7 +120,10 @@ class CostArbitrator : public Arbitrator<EnvironmentModelT, CommandT, SubCommand
     using Ptr = std::shared_ptr<CostArbitrator>;
     using ConstPtr = std::shared_ptr<const CostArbitrator>;
 
+    using BatchCostEstimatorT = BatchCostEstimator<EnvironmentModelT, SubCommandT>;
+    using CandidateT = typename BatchCostEstimatorT::Candidate;
     using CostEstimatorT = CostEstimator<EnvironmentModelT, SubCommandT>;
+    using PerOptionToBatchAdapterT = PerOptionToBatchAdapter<EnvironmentModelT, SubCommandT>;
     using PlaceboVerifierT = verification::PlaceboVerifier<EnvironmentModelT, SubCommandT>;
     using VerifierT = verification::Verifier<EnvironmentModelT, SubCommandT>;
 
@@ -41,22 +135,15 @@ class CostArbitrator : public Arbitrator<EnvironmentModelT, CommandT, SubCommand
 
         enum Flags { NoFlags = 0b0, Interruptable = 0b1, Fallback = 0b10 };
 
-        Option(const typename Behavior<EnvironmentModelT, SubCommandT>::Ptr& behavior,
-               const FlagsT& flags,
-               const typename CostEstimatorT::Ptr& costEstimator)
-                : ArbitratorBase::Option(behavior, flags), costEstimator_{costEstimator} {
+        Option(const typename Behavior<EnvironmentModelT, SubCommandT>::Ptr& behavior, const FlagsT& flags)
+                : ArbitratorBase::Option(behavior, flags) {
         }
 
-        double estimateCost(const Time& time,
-                            const EnvironmentModelT& environmentModel,
-                            const SubCommandT& command,
-                            bool isActive) const {
-            double cost = costEstimator_->estimateCost(time, environmentModel, command, isActive);
-            lastEstimatedCost_ = cost;
-            return cost;
+        std::optional<double> lastEstimatedCost(const Time& time) const {
+            return lastEstimatedCost_.cached(time);
         }
-        void resetLastEstimatedCost() const {
-            lastEstimatedCost_.reset();
+        void cacheLastEstimatedCost(const Time& time, const double& cost) const {
+            lastEstimatedCost_.cache(time, cost);
         }
 
         /*!
@@ -88,23 +175,31 @@ class CostArbitrator : public Arbitrator<EnvironmentModelT, CommandT, SubCommand
         YAML::Node toYaml(const Time& time, const EnvironmentModelT& environmentModel) const override;
 
     private:
-        typename CostEstimatorT::Ptr costEstimator_;
-        mutable std::optional<double> lastEstimatedCost_;
+        mutable util_caching::Cache<Time, double> lastEstimatedCost_;
     };
 
 
     explicit CostArbitrator(const std::string& name = "CostArbitrator",
+                            const typename BatchCostEstimatorT::Ptr& batchCostEstimator =
+                                std::make_shared<PlaceboCostEstimator<EnvironmentModelT, SubCommandT>>(),
                             typename VerifierT::Ptr verifier = std::make_shared<PlaceboVerifierT>())
-            : ArbitratorBase(name, verifier) {};
+            : ArbitratorBase(name, verifier), costEstimator_{batchCostEstimator} {};
+
+    explicit CostArbitrator(const std::string& name,
+                            const typename CostEstimatorT::Ptr& costEstimator,
+                            typename VerifierT::Ptr verifier = std::make_shared<PlaceboVerifierT>())
+            : ArbitratorBase(name, verifier),
+              costEstimator_(std::make_shared<PerOptionToBatchAdapterT>(costEstimator)) {
+    }
 
 
     void addOption(const typename Behavior<EnvironmentModelT, SubCommandT>::Ptr& behavior,
-                   const typename Option::FlagsT& flags,
-                   const typename CostEstimatorT::Ptr& costEstimator) {
-        typename Option::Ptr option = std::make_shared<Option>(behavior, flags, costEstimator);
+                   const typename Option::FlagsT& flags) override {
+        typename Option::Ptr option = std::make_shared<Option>(behavior, flags);
         this->addOptionImpl(option);
     }
 
+
     /*!
      * \brief Returns a yaml representation of the arbitrator object with its current state
      *
@@ -124,17 +219,25 @@ class CostArbitrator : public Arbitrator<EnvironmentModelT, CommandT, SubCommand
         const typename ArbitratorBase::Options& options,
         const Time& time,
         const EnvironmentModelT& environmentModel) const override {
-        // reset lastEstimatedCost for all behaviorOptions
-        for (const auto& optionBase : this->options()) {
-            typename Option::ConstPtr option = std::dynamic_pointer_cast<const Option>(optionBase);
-            option->resetLastEstimatedCost();
+
+
+        std::vector<typename Option::Ptr> validOptions = collectValidOptions(options, time, environmentModel);
+
+        if (validOptions.size() < 2) {
+            // no need to estimate costs if there is nothing to sort
+            return typename ArbitratorBase::Options(validOptions.begin(), validOptions.end());
         }
 
-        // sort given options by using a multiset
-        std::multimap<double, typename ArbitratorBase::Option::Ptr> sortedOptionsMap;
+        return sortOptionsByCost(validOptions, time, environmentModel);
+    }
 
+    std::vector<typename Option::Ptr> collectValidOptions(const typename ArbitratorBase::Options& options,
+                                                          const Time& time,
+                                                          const EnvironmentModelT& environmentModel) const {
+
+        std::vector<typename Option::Ptr> validOptions;
         for (auto& optionBase : options) {
-            typename Option::Ptr option = std::dynamic_pointer_cast<Option>(optionBase);
+            auto option = std::dynamic_pointer_cast<Option>(optionBase);
 
             const bool isActive = this->isActive(option);
 
@@ -146,22 +249,52 @@ class CostArbitrator : public Arbitrator<EnvironmentModelT, CommandT, SubCommand
                 command = this->getAndVerifyCommand(option, time, environmentModel);
                 option->behavior()->loseControl(time, environmentModel);
             }
+            if (command) {
+                validOptions.push_back(option);
+            }
+        }
+        return validOptions;
+    }
+
+    typename ArbitratorBase::Options sortOptionsByCost(const std::vector<typename Option::Ptr>& options,
+                                                       const Time& time,
+                                                       const EnvironmentModelT& environmentModel) const {
+        std::vector<CandidateT> candidates;
+        candidates.reserve(options.size());
+        for (const auto& option : options) {
+            // The command has already been computed (and verified), so we can safely retrieve it from cache
+            const std::optional<SubCommandT> command = option->getCommand(time, environmentModel);
             if (!command) {
-                continue;
+                throw InvalidStateError("Could not retrieve cached command.");
             }
+            const bool isActive = this->isActive(option);
+            candidates.push_back(CandidateT{command.value(), isActive});
+        }
 
-            double cost = option->estimateCost(time, environmentModel, command.value(), isActive);
-            sortedOptionsMap.insert({cost, option});
+        std::vector<double> costs = costEstimator_->estimateCosts(time, environmentModel, candidates);
+        if (costs.size() != candidates.size()) {
+            throw InvalidCostError("CostEstimator returned mismatching number of costs.");
         }
 
-        // copy back to vector (these are pointers anyway, so copying is cheap)
+        // Sort options by cost
+        std::multimap<double, typename ArbitratorBase::Option::Ptr> sortedOptionsMap;
+        for (std::size_t i = 0; i < options.size(); ++i) {
+            options[i]->cacheLastEstimatedCost(time, costs[i]);
+            sortedOptionsMap.insert({costs[i], options[i]});
+        }
+
+        // Copy back to vector
         typename ArbitratorBase::Options sortedOptionsVector;
         sortedOptionsVector.reserve(options.size());
         for (const auto& sortedOption : sortedOptionsMap) {
             sortedOptionsVector.push_back(sortedOption.second);
         }
+
         return sortedOptionsVector;
     }
+
+
+    typename BatchCostEstimatorT::Ptr costEstimator_;
 };
 } // namespace arbitration_graphs
 
diff --git a/include/arbitration_graphs/exceptions.hpp b/include/arbitration_graphs/exceptions.hpp
index aada0be9..fcc93f56 100644
--- a/include/arbitration_graphs/exceptions.hpp
+++ b/include/arbitration_graphs/exceptions.hpp
@@ -20,6 +20,14 @@ class InvalidArgumentsError : public std::runtime_error {
     using std::runtime_error::runtime_error;
 };
 
+class InvalidCostError : public std::runtime_error {
+    using std::runtime_error::runtime_error;
+};
+
+class InvalidStateError : public std::runtime_error {
+    using std::runtime_error::runtime_error;
+};
+
 class VerificationError : public std::runtime_error {
     using std::runtime_error::runtime_error;
 };
diff --git a/include/arbitration_graphs/internal/cost_arbitrator_io.hpp b/include/arbitration_graphs/internal/cost_arbitrator_io.hpp
index c2112ad7..299edd11 100644
--- a/include/arbitration_graphs/internal/cost_arbitrator_io.hpp
+++ b/include/arbitration_graphs/internal/cost_arbitrator_io.hpp
@@ -20,8 +20,8 @@ std::ostream& CostArbitrator<EnvironmentModelT, CommandT, SubCommandT>::Option::
     const std::string& prefix,
     const std::string& suffix) const {
 
-    if (lastEstimatedCost_) {
-        output << std::fixed << std::setprecision(3) << "- (cost: " << *lastEstimatedCost_ << ") ";
+    if (lastEstimatedCost(time)) {
+        output << std::fixed << std::setprecision(3) << "- (cost: " << *lastEstimatedCost(time) << ") ";
     } else {
         output << "- (cost:  n.a.) ";
     }
@@ -34,8 +34,8 @@ template <typename EnvironmentModelT, typename CommandT, typename SubCommandT>
 YAML::Node CostArbitrator<EnvironmentModelT, CommandT, SubCommandT>::Option::toYaml(
     const Time& time, const EnvironmentModelT& environmentModel) const {
     YAML::Node node = ArbitratorBase::Option::toYaml(time, environmentModel);
-    if (lastEstimatedCost_) {
-        node["cost"] = *lastEstimatedCost_;
+    if (lastEstimatedCost(time)) {
+        node["cost"] = *lastEstimatedCost(time);
     }
     return node;
 }
diff --git a/python_bindings/include/arbitration_graphs_py/cost_arbitrator.hpp b/python_bindings/include/arbitration_graphs_py/cost_arbitrator.hpp
index eb72a78d..6fd3d43c 100644
--- a/python_bindings/include/arbitration_graphs_py/cost_arbitrator.hpp
+++ b/python_bindings/include/arbitration_graphs_py/cost_arbitrator.hpp
@@ -16,6 +16,29 @@ namespace arbitration_graphs_py {
 namespace py = pybind11;
 namespace ag = arbitration_graphs;
 
+class PyBatchCostEstimator : public ag::BatchCostEstimator<EnvironmentModelWrapper, CommandWrapper>,
+                             public py::trampoline_self_life_support {
+public:
+    using BaseT = ag::BatchCostEstimator<EnvironmentModelWrapper, CommandWrapper>;
+    using CandidateT = typename BaseT::Candidate;
+
+    using BaseT::BaseT;
+
+    virtual ~PyBatchCostEstimator() = default;
+    PyBatchCostEstimator(const PyBatchCostEstimator&) = default;
+    PyBatchCostEstimator(PyBatchCostEstimator&&) = default;
+    PyBatchCostEstimator& operator=(const PyBatchCostEstimator&) = delete;
+    PyBatchCostEstimator& operator=(PyBatchCostEstimator&&) = delete;
+
+    // NOLINTBEGIN(readability-function-size)
+    std::vector<double> estimateCosts(const ag::Time& time,
+                                      const EnvironmentModelWrapper& env,
+                                      const std::vector<CandidateT>& candidates) override {
+        PYBIND11_OVERRIDE_PURE_NAME(std::vector<double>, BaseT, "estimate_costs", estimateCosts, time, env, candidates);
+    }
+    // NOLINTEND(readability-function-size)
+};
+
 /// @brief A wrapper class (a.k.a. trampoline class) for the CostEstimator class to allow Python overrides.
 class PyCostEstimator : public ag::CostEstimator<EnvironmentModelWrapper, CommandWrapper>,
                         py::trampoline_self_life_support {
@@ -41,6 +64,24 @@ class PyCostEstimator : public ag::CostEstimator<EnvironmentModelWrapper, Comman
     // NOLINTEND(readability-function-size)
 };
 
+inline void bindBatchCostEstimator(py::module& module) {
+    using BatchCostEstimatorT = ag::BatchCostEstimator<EnvironmentModelWrapper, CommandWrapper>;
+
+    using CandidateT = typename BatchCostEstimatorT::Candidate;
+
+    py::classh<BatchCostEstimatorT, PyBatchCostEstimator> batchCostEstimator(module, "BatchCostEstimator");
+    batchCostEstimator.def(py::init<>())
+        .def("estimate_costs",
+             &BatchCostEstimatorT::estimateCosts,
+             py::arg("time"),
+             py::arg("environment_model"),
+             py::arg("candidates"));
+
+    py::classh<CandidateT>(batchCostEstimator, "Candidate")
+        .def_readonly("command", &CandidateT::command)
+        .def_readonly("is_active", &CandidateT::isActive);
+}
+
 inline void bindCostEstimator(py::module& module) {
     using CostEstimatorT = ag::CostEstimator<EnvironmentModelWrapper, CommandWrapper>;
 
@@ -54,6 +95,19 @@ inline void bindCostEstimator(py::module& module) {
              py::arg("is_active"));
 }
 
+inline void bindPlaceboCostEstimator(py::module& module) {
+    using BatchCostEstimatorT = ag::BatchCostEstimator<EnvironmentModelWrapper, CommandWrapper>;
+    using PlaceboCostEstimatorT = ag::PlaceboCostEstimator<EnvironmentModelWrapper, CommandWrapper>;
+
+    py::classh<PlaceboCostEstimatorT, BatchCostEstimatorT>(module, "PlaceboCostEstimator")
+        .def(py::init<>())
+        .def("estimate_costs",
+             &BatchCostEstimatorT::estimateCosts,
+             py::arg("time"),
+             py::arg("environment_model"),
+             py::arg("candidates"));
+}
+
 inline void bindCostArbitrator(py::module& module) {
     using Time = ag::Time;
 
@@ -62,6 +116,8 @@ inline void bindCostArbitrator(py::module& module) {
 
     using BehaviorT = typename ArbitratorT::Behavior;
 
+    using BatchCostEstimatorT = ag::BatchCostEstimator<EnvironmentModelWrapper, CommandWrapper>;
+    using PlaceboCostEstimatorT = ag::PlaceboCostEstimator<EnvironmentModelWrapper, CommandWrapper>;
     using CostArbitratorT = ag::CostArbitrator<EnvironmentModelWrapper, CommandWrapper>;
     using CostEstimatorT = ag::CostEstimator<EnvironmentModelWrapper, CommandWrapper>;
 
@@ -71,15 +127,21 @@ inline void bindCostArbitrator(py::module& module) {
     using VerifierT = ag::verification::Verifier<EnvironmentModelWrapper, CommandWrapper>;
     using PlaceboVerifierT = ag::verification::PlaceboVerifier<EnvironmentModelWrapper, CommandWrapper>;
 
+    bindBatchCostEstimator(module);
     bindCostEstimator(module);
+    bindPlaceboCostEstimator(module);
 
     py::classh<CostArbitratorT, ArbitratorT> costArbitrator(module, "CostArbitrator");
     costArbitrator
-        .def(py::init<const std::string&, const VerifierT::Ptr&>(),
+        .def(py::init<const std::string&, const std::shared_ptr<BatchCostEstimatorT>&, const VerifierT::Ptr&>(),
              py::arg("name") = "CostArbitrator",
-             py::arg("verifier") = PlaceboVerifierT())
-        .def(
-            "add_option", &CostArbitratorT::addOption, py::arg("behavior"), py::arg("flags"), py::arg("cost_estimator"))
+             py::arg("batch_cost_estimator") = std::make_shared<PlaceboCostEstimatorT>(),
+             py::arg("verifier") = std::make_shared<PlaceboVerifierT>())
+        .def(py::init<const std::string&, const std::shared_ptr<CostEstimatorT>&, const VerifierT::Ptr&>(),
+             py::arg("name"),
+             py::arg("cost_estimator"),
+             py::arg("verifier") = std::make_shared<PlaceboVerifierT>())
+        .def("add_option", &CostArbitratorT::addOption, py::arg("behavior"), py::arg("flags"))
         .def(
             "to_yaml",
             [](const CostArbitratorT& self, const Time& time, const EnvironmentModelWrapper& environmentModel) {
@@ -90,10 +152,7 @@ inline void bindCostArbitrator(py::module& module) {
         .def("__repr__", [](const CostArbitratorT& self) { return "<CostArbitrator '" + self.name() + "'>"; });
 
     py::classh<OptionT, ArbitratorOptionT> option(costArbitrator, "Option");
-    option.def(py::init<const typename BehaviorT::Ptr&, const FlagsT&, const typename CostEstimatorT::Ptr&>(),
-               py::arg("behavior"),
-               py::arg("flags"),
-               py::arg("cost_estimator"));
+    option.def(py::init<const typename BehaviorT::Ptr&, const FlagsT&>(), py::arg("behavior"), py::arg("flags"));
 
     py::enum_<typename OptionT::Flags>(option, "Flags")
         .value("NO_FLAGS", OptionT::NoFlags)
diff --git a/python_bindings/include/arbitration_graphs_py/exceptions.hpp b/python_bindings/include/arbitration_graphs_py/exceptions.hpp
index c81d4fe5..ef1e3326 100644
--- a/python_bindings/include/arbitration_graphs_py/exceptions.hpp
+++ b/python_bindings/include/arbitration_graphs_py/exceptions.hpp
@@ -15,6 +15,8 @@ inline void bindExceptions(py::module& module) {
     py::register_exception<ag::InvocationConditionIsFalseError>(module, "InvocationConditionIsFalseError");
     py::register_exception<ag::MultipleReferencesToSameInstanceError>(module, "MultipleReferencesToSameInstanceError");
     py::register_exception<ag::InvalidArgumentsError>(module, "InvalidArgumentsError");
+    py::register_exception<ag::InvalidCostError>(module, "InvalidCostError");
+    py::register_exception<ag::InvalidStateError>(module, "InvalidStateError");
     py::register_exception<ag::VerificationError>(module, "VerificationError");
     py::register_exception<ag::NoApplicableOptionPassedVerificationError>(module,
                                                                           "NoApplicableOptionPassedVerificationError");
diff --git a/python_bindings/src/arbitration_graphs/__init__.py b/python_bindings/src/arbitration_graphs/__init__.py
index d63d34e4..2b09d679 100644
--- a/python_bindings/src/arbitration_graphs/__init__.py
+++ b/python_bindings/src/arbitration_graphs/__init__.py
@@ -5,14 +5,18 @@
 from .arbitration_graphs_py import (
     ApplicableOptionFailedVerificationError,
     Arbitrator,
+    BatchCostEstimator,
     Behavior,
     CostArbitrator,
     CostEstimator,
     GetCommandCalledWithoutGainControlError,
     InvalidArgumentsError,
+    InvalidCostError,
+    InvalidStateError,
     InvocationConditionIsFalseError,
     MultipleReferencesToSameInstanceError,
     NoApplicableOptionPassedVerificationError,
+    PlaceboCostEstimator,
     PriorityArbitrator,
     RandomArbitrator,
     VerificationError,
@@ -22,14 +26,18 @@
 __all__ = [
     "ApplicableOptionFailedVerificationError",
     "Arbitrator",
+    "BatchCostEstimator",
     "Behavior",
     "CostArbitrator",
     "CostEstimator",
     "GetCommandCalledWithoutGainControlError",
     "InvalidArgumentsError",
+    "InvalidCostError",
+    "InvalidStateError",
     "InvocationConditionIsFalseError",
     "MultipleReferencesToSameInstanceError",
     "NoApplicableOptionPassedVerificationError",
+    "PlaceboCostEstimator",
     "PriorityArbitrator",
     "RandomArbitrator",
     "VerificationError",
diff --git a/python_bindings/src/arbitration_graphs/__init__.pyi b/python_bindings/src/arbitration_graphs/__init__.pyi
index a133c544..cbd2be7b 100644
--- a/python_bindings/src/arbitration_graphs/__init__.pyi
+++ b/python_bindings/src/arbitration_graphs/__init__.pyi
@@ -1,6 +1,6 @@
 # pyright: reportAny=false,reportExplicitAny=false
-
 import typing
+from dataclasses import dataclass
 
 from typing_extensions import override
 
@@ -15,14 +15,18 @@ from arbitration_graphs.typing import (
 __all__ = [
     "ApplicableOptionFailedVerificationError",
     "Arbitrator",
+    "BatchCostEstimator",
     "Behavior",
     "CostArbitrator",
     "CostEstimator",
     "GetCommandCalledWithoutGainControlError",
     "InvalidArgumentsError",
+    "InvalidCostError",
+    "InvalidStateError",
     "InvocationConditionIsFalseError",
     "MultipleReferencesToSameInstanceError",
     "NoApplicableOptionPassedVerificationError",
+    "PlaceboCostEstimator",
     "PriorityArbitrator",
     "RandomArbitrator",
     "VerificationError",
@@ -98,6 +102,20 @@ class Arbitrator(Behavior):
     def lose_control(self, time: Time, environment_model: EnvironmentModel) -> None: ...
     def options(self) -> list[Option]: ...
 
+class BatchCostEstimator:
+    @dataclass
+    class Candidate:
+        command: Command
+        is_active: bool
+
+    def __init__(self) -> None: ...
+    def estimate_costs(
+        self,
+        time: Time,
+        environment_model: EnvironmentModel,
+        candidates: list[Candidate],
+    ) -> list[float]: ...
+
 class Behavior:
     def __init__(self, name: str = "Behavior") -> None: ...
     @override
@@ -178,15 +196,25 @@ class CostArbitrator(Arbitrator):
             self,
             behavior: Behavior,
             flags: typing.SupportsInt,
-            cost_estimator: CostEstimator,
         ) -> None: ...
 
+    @typing.overload
     def __init__(
-        self, name: str = "CostArbitrator", verifier: verification.Verifier = ...
+        self,
+        name: str = "CostArbitrator",
+        batch_cost_estimator: BatchCostEstimator = ...,
+        verifier: verification.Verifier = ...,
+    ) -> None: ...
+    @typing.overload
+    def __init__(
+        self,
+        name: str,
+        cost_estimator: CostEstimator,
+        verifier: verification.Verifier = ...,
     ) -> None: ...
     @override
     def __repr__(self) -> str: ...
-    @typing.overload
+    @override
     def add_option(
         self,
         behavior: Behavior,
@@ -197,13 +225,6 @@ class CostArbitrator(Arbitrator):
         Use the overload passing a CostEstimator instead.
         """
         ...
-    @typing.overload
-    def add_option(
-        self,
-        behavior: Behavior,
-        flags: typing.SupportsInt,
-        cost_estimator: CostEstimator,
-    ) -> None: ...
     @override
     def to_yaml(
         self, time: Time, environment_model: EnvironmentModel
@@ -228,12 +249,28 @@ class InvalidArgumentsError(Exception):
 class InvocationConditionIsFalseError(Exception):
     pass
 
+class InvalidCostError(Exception):
+    pass
+
+class InvalidStateError(Exception):
+    pass
+
 class MultipleReferencesToSameInstanceError(Exception):
     pass
 
 class NoApplicableOptionPassedVerificationError(Exception):
     pass
 
+class PlaceboCostEstimator(BatchCostEstimator):
+    def __init__(self) -> None: ...
+    @override
+    def estimate_costs(
+        self,
+        time: Time,
+        environment_model: EnvironmentModel,
+        candidates: list[BatchCostEstimator.Candidate],
+    ) -> list[float]: ...
+
 class PriorityArbitrator(Arbitrator):
     class Option(Arbitrator.Option):
         # The nested "Flags" class intentionally differs between Arbitrator subtypes.
diff --git a/python_bindings/test/cost_estimator.py b/python_bindings/test/cost_estimator.py
index f2bf0b92..8434a4aa 100644
--- a/python_bindings/test/cost_estimator.py
+++ b/python_bindings/test/cost_estimator.py
@@ -1,8 +1,8 @@
-from typing import Mapping, final
+from typing import Mapping, cast, final
 
 from typing_extensions import override
 
-from arbitration_graphs import CostEstimator
+from arbitration_graphs import BatchCostEstimator, CostEstimator
 from arbitration_graphs.typing import Time
 
 from .dummy_types import DummyCommand, DummyEnvironmentModel
@@ -35,3 +35,28 @@ def estimate_cost(
         return (self.cost_map[command] + self.activation_costs) / (
             1 + self.activation_costs
         )
+
+
+@final
+class ScaledCostEstimatorFromCostMap(BatchCostEstimator):
+    def __init__(self, cost_map: Mapping[DummyCommand, float]):
+        super().__init__()
+        self.cost_map = cost_map
+
+    @override
+    def estimate_costs(
+        self,
+        time: Time,
+        environment_model: DummyEnvironmentModel,
+        candidates: list[BatchCostEstimator.Candidate],
+    ) -> list[float]:
+        if not candidates:
+            return []
+
+        raw_costs = [self.cost_map[cast(DummyCommand, c.command)] for c in candidates]
+        max_cost = max(raw_costs)
+
+        if max_cost == 0:
+            return [0.0 for _ in raw_costs]
+
+        return [c / max_cost for c in raw_costs]
diff --git a/python_bindings/test/test_cost_arbitrator.py b/python_bindings/test/test_cost_arbitrator.py
index 4412f249..67f7adf5 100644
--- a/python_bindings/test/test_cost_arbitrator.py
+++ b/python_bindings/test/test_cost_arbitrator.py
@@ -8,7 +8,7 @@
 
 import arbitration_graphs as ag
 
-from .cost_estimator import CostEstimatorFromCostMap
+from .cost_estimator import CostEstimatorFromCostMap, ScaledCostEstimatorFromCostMap
 from .dummy_types import (
     DummyBehavior,
     DummyCommand,
@@ -28,14 +28,17 @@ def setUp(self):
         self.cost_map = {
             DummyCommand("low_cost"): 0,
             DummyCommand("mid_cost"): 0.5,
-            DummyCommand("high_cost"): 1,
+            DummyCommand("high_cost"): 2,
         }
-        self.cost_estimator = CostEstimatorFromCostMap(self.cost_map)
-        self.cost_estimator_with_activation_costs = CostEstimatorFromCostMap(
+        cost_estimator = CostEstimatorFromCostMap(self.cost_map)
+        cost_estimator_with_activation_costs = CostEstimatorFromCostMap(
             self.cost_map, 10
         )
 
-        self.test_cost_arbitrator = ag.CostArbitrator()
+        self.test_cost_arbitrator = ag.CostArbitrator("CostArbitrator", cost_estimator)
+        self.test_cost_arbitrator_with_activation_costs = ag.CostArbitrator(
+            "CostArbitrator", cost_estimator_with_activation_costs
+        )
 
         self.environment_model = DummyEnvironmentModel()
 
@@ -58,12 +61,10 @@ def test_basic_functionality(self):
         self.test_cost_arbitrator.add_option(
             self.test_behavior_low_cost,
             ag.CostArbitrator.Option.Flags.NO_FLAGS,
-            self.cost_estimator,
         )
         self.test_cost_arbitrator.add_option(
             self.test_behavior_low_cost,
             ag.CostArbitrator.Option.Flags.NO_FLAGS,
-            self.cost_estimator,
         )
         self.assertFalse(
             self.test_cost_arbitrator.check_invocation_condition(
@@ -79,12 +80,10 @@ def test_basic_functionality(self):
         self.test_cost_arbitrator.add_option(
             self.test_behavior_high_cost,
             ag.CostArbitrator.Option.Flags.NO_FLAGS,
-            self.cost_estimator,
         )
         self.test_cost_arbitrator.add_option(
             self.test_behavior_mid_cost,
             ag.CostArbitrator.Option.Flags.NO_FLAGS,
-            self.cost_estimator,
         )
 
         self.assertTrue(
@@ -149,27 +148,77 @@ def test_basic_functionality(self):
             self.test_cost_arbitrator.get_command(self.time, self.environment_model),
         )
 
+    def test_default_constructor(self):
+        default_cost_arbitrator = ag.CostArbitrator()
+
+        default_cost_arbitrator.add_option(
+            self.test_behavior_low_cost,
+            ag.CostArbitrator.Option.Flags.NO_FLAGS,
+        )
+        default_cost_arbitrator.add_option(
+            self.test_behavior_low_cost,
+            ag.CostArbitrator.Option.Flags.NO_FLAGS,
+        )
+        default_cost_arbitrator.add_option(
+            self.test_behavior_high_cost,
+            ag.CostArbitrator.Option.Flags.NO_FLAGS,
+        )
+        default_cost_arbitrator.add_option(
+            self.test_behavior_mid_cost,
+            ag.CostArbitrator.Option.Flags.NO_FLAGS,
+        )
+
+        self.assertTrue(
+            default_cost_arbitrator.check_invocation_condition(
+                self.time, self.environment_model
+            )
+        )
+        self.assertFalse(
+            default_cost_arbitrator.check_commitment_condition(
+                self.time, self.environment_model
+            )
+        )
+
+        default_cost_arbitrator.gain_control(self.time, self.environment_model)
+
+        # With PlaceboCostEstimator:
+        # Costs are assigned by order: 0, 1, 2, ...
+        # low_cost is invalid (invocation=false) and filtered out.
+        # high_cost becomes first valid option → cost 0
+        # mid_cost becomes second valid option → cost 1
+        # => high_cost must win even though mid_cost would normally be cheaper.
+        self.assertEqual(
+            "high_cost",
+            default_cost_arbitrator.get_command(self.time, self.environment_model),
+        )
+
+        yaml_node = default_cost_arbitrator.to_yaml(self.time, self.environment_model)
+
+        cost_high = cast(float, yaml_node["options"][2]["cost"])
+        cost_mid = cast(float, yaml_node["options"][3]["cost"])
+
+        self.assertAlmostEqual(0.0, cost_high, delta=1e-6)
+        self.assertAlmostEqual(1.0, cost_mid, delta=1e-6)
+
+        self.assertEqual(2, yaml_node["activeBehavior"])
+
     def test_printout(self):
         # Adding options
         self.test_cost_arbitrator.add_option(
             self.test_behavior_low_cost,
             ag.CostArbitrator.Option.Flags.NO_FLAGS,
-            self.cost_estimator,
         )
         self.test_cost_arbitrator.add_option(
             self.test_behavior_low_cost,
             ag.CostArbitrator.Option.Flags.NO_FLAGS,
-            self.cost_estimator,
         )
         self.test_cost_arbitrator.add_option(
             self.test_behavior_high_cost,
             ag.CostArbitrator.Option.Flags.NO_FLAGS,
-            self.cost_estimator,
         )
         self.test_cost_arbitrator.add_option(
             self.test_behavior_mid_cost,
             ag.CostArbitrator.Option.Flags.NO_FLAGS,
-            self.cost_estimator,
         )
 
         # fmt: off
@@ -200,7 +249,7 @@ def test_printout(self):
             ps.invocation_true + ps.commitment_true + "CostArbitrator\n" +
             "    - (cost:  n.a.) " + ps.invocation_false + ps.commitment_false + "low_cost\n" +
             "    - (cost:  n.a.) " + ps.invocation_false + ps.commitment_false + "low_cost\n" +
-            "    - (cost: 1.000) " + ps.invocation_true + ps.commitment_true + "high_cost\n" +
+            "    - (cost: 2.000) " + ps.invocation_true + ps.commitment_true + "high_cost\n" +
             " -> - (cost: 0.500) " + ps.invocation_true + ps.commitment_false + "mid_cost"
         )
         # fmt: on
@@ -215,22 +264,18 @@ def test_to_yaml(self):
         self.test_cost_arbitrator.add_option(
             self.test_behavior_low_cost,
             ag.CostArbitrator.Option.Flags.NO_FLAGS,
-            self.cost_estimator,
         )
         self.test_cost_arbitrator.add_option(
             self.test_behavior_low_cost,
             ag.CostArbitrator.Option.Flags.NO_FLAGS,
-            self.cost_estimator,
         )
         self.test_cost_arbitrator.add_option(
             self.test_behavior_high_cost,
             ag.CostArbitrator.Option.Flags.NO_FLAGS,
-            self.cost_estimator,
         )
         self.test_cost_arbitrator.add_option(
             self.test_behavior_mid_cost,
             ag.CostArbitrator.Option.Flags.NO_FLAGS,
-            self.cost_estimator,
         )
 
         yaml_node = self.test_cost_arbitrator.to_yaml(self.time, self.environment_model)
@@ -276,118 +321,157 @@ def test_to_yaml(self):
 
         cost_2 = cast(float, yaml_node["options"][2]["cost"])
         cost_3 = cast(float, yaml_node["options"][3]["cost"])
-        self.assertAlmostEqual(1.0, cost_2, delta=1e-3)
+        self.assertAlmostEqual(2.0, cost_2, delta=1e-3)
         self.assertAlmostEqual(0.5, cost_3, delta=1e-3)
 
         self.assertTrue("activeBehavior" in yaml_node)
         self.assertEqual(3, yaml_node["activeBehavior"])
 
+    def test_batch_cost_estimator(self):
+        batch_estimator = ScaledCostEstimatorFromCostMap(self.cost_map)
+        batch_arbitrator = ag.CostArbitrator("CostArbitrator", batch_estimator)
+
+        batch_arbitrator.add_option(
+            self.test_behavior_low_cost, ag.CostArbitrator.Option.Flags.NO_FLAGS
+        )
+        batch_arbitrator.add_option(
+            self.test_behavior_low_cost, ag.CostArbitrator.Option.Flags.NO_FLAGS
+        )
+        batch_arbitrator.add_option(
+            self.test_behavior_high_cost, ag.CostArbitrator.Option.Flags.NO_FLAGS
+        )
+        batch_arbitrator.add_option(
+            self.test_behavior_mid_cost, ag.CostArbitrator.Option.Flags.NO_FLAGS
+        )
+
+        batch_arbitrator.gain_control(self.time, self.environment_model)
+        self.assertEqual(
+            "mid_cost", batch_arbitrator.get_command(self.time, self.environment_model)
+        )
+
+        yaml_node = batch_arbitrator.to_yaml(self.time, self.environment_model)
+        # The costs are scaled to [0,1] in this estimator
+        cost_2 = cast(float, yaml_node["options"][2]["cost"])
+        cost_3 = cast(float, yaml_node["options"][3]["cost"])
+        self.assertAlmostEqual(1.0, cost_2, delta=1e-3)
+        self.assertAlmostEqual(0.25, cost_3, delta=1e-3)
+
     def test_basic_functionality_with_interruptable_options_and_activation_costs(self):
         # If there are no options yet, the invocationCondition should be false
         self.assertFalse(
-            self.test_cost_arbitrator.check_invocation_condition(
+            self.test_cost_arbitrator_with_activation_costs.check_invocation_condition(
                 self.time, self.environment_model
             )
         )
         self.assertFalse(
-            self.test_cost_arbitrator.check_commitment_condition(
+            self.test_cost_arbitrator_with_activation_costs.check_commitment_condition(
                 self.time, self.environment_model
             )
         )
 
         # InvocationCondition is true if any option has true invocationCondition
-        self.test_cost_arbitrator.add_option(
+        self.test_cost_arbitrator_with_activation_costs.add_option(
             self.test_behavior_low_cost,
             ag.CostArbitrator.Option.Flags.INTERRUPTABLE,
-            self.cost_estimator_with_activation_costs,
         )
-        self.test_cost_arbitrator.add_option(
+        self.test_cost_arbitrator_with_activation_costs.add_option(
             self.test_behavior_low_cost,
             ag.CostArbitrator.Option.Flags.INTERRUPTABLE,
-            self.cost_estimator_with_activation_costs,
         )
         self.assertFalse(
-            self.test_cost_arbitrator.check_invocation_condition(
+            self.test_cost_arbitrator_with_activation_costs.check_invocation_condition(
                 self.time, self.environment_model
             )
         )
         self.assertFalse(
-            self.test_cost_arbitrator.check_commitment_condition(
+            self.test_cost_arbitrator_with_activation_costs.check_commitment_condition(
                 self.time, self.environment_model
             )
         )
 
-        self.test_cost_arbitrator.add_option(
+        self.test_cost_arbitrator_with_activation_costs.add_option(
             self.test_behavior_high_cost,
             ag.CostArbitrator.Option.Flags.INTERRUPTABLE,
-            self.cost_estimator_with_activation_costs,
         )
-        self.test_cost_arbitrator.add_option(
+        self.test_cost_arbitrator_with_activation_costs.add_option(
             self.test_behavior_mid_cost,
             ag.CostArbitrator.Option.Flags.INTERRUPTABLE,
-            self.cost_estimator_with_activation_costs,
         )
 
         self.assertTrue(
-            self.test_cost_arbitrator.check_invocation_condition(
+            self.test_cost_arbitrator_with_activation_costs.check_invocation_condition(
                 self.time, self.environment_model
             )
         )
         self.assertFalse(
-            self.test_cost_arbitrator.check_commitment_condition(
+            self.test_cost_arbitrator_with_activation_costs.check_commitment_condition(
                 self.time, self.environment_model
             )
         )
 
-        self.test_cost_arbitrator.gain_control(self.time, self.environment_model)
+        self.test_cost_arbitrator_with_activation_costs.gain_control(
+            self.time, self.environment_model
+        )
         self.assertEqual(
             "mid_cost",
-            self.test_cost_arbitrator.get_command(self.time, self.environment_model),
+            self.test_cost_arbitrator_with_activation_costs.get_command(
+                self.time, self.environment_model
+            ),
         )
         self.assertEqual(
             "mid_cost",
-            self.test_cost_arbitrator.get_command(self.time, self.environment_model),
+            self.test_cost_arbitrator_with_activation_costs.get_command(
+                self.time, self.environment_model
+            ),
         )
 
         self.test_behavior_mid_cost.invocation_condition = False
         self.assertTrue(
-            self.test_cost_arbitrator.check_invocation_condition(
+            self.test_cost_arbitrator_with_activation_costs.check_invocation_condition(
                 self.time, self.environment_model
             )
         )
         self.assertTrue(
-            self.test_cost_arbitrator.check_commitment_condition(
+            self.test_cost_arbitrator_with_activation_costs.check_commitment_condition(
                 self.time, self.environment_model
             )
         )
         self.assertEqual(
             "high_cost",
-            self.test_cost_arbitrator.get_command(self.time, self.environment_model),
+            self.test_cost_arbitrator_with_activation_costs.get_command(
+                self.time, self.environment_model
+            ),
         )
         self.assertEqual(
             "high_cost",
-            self.test_cost_arbitrator.get_command(self.time, self.environment_model),
+            self.test_cost_arbitrator_with_activation_costs.get_command(
+                self.time, self.environment_model
+            ),
         )
 
         # high_cost behavior is not interruptable -> high_cost should stay active
         self.test_behavior_mid_cost.invocation_condition = True
         self.assertTrue(
-            self.test_cost_arbitrator.check_invocation_condition(
+            self.test_cost_arbitrator_with_activation_costs.check_invocation_condition(
                 self.time, self.environment_model
             )
         )
         self.assertTrue(
-            self.test_cost_arbitrator.check_commitment_condition(
+            self.test_cost_arbitrator_with_activation_costs.check_commitment_condition(
                 self.time, self.environment_model
             )
         )
         self.assertEqual(
             "high_cost",
-            self.test_cost_arbitrator.get_command(self.time, self.environment_model),
+            self.test_cost_arbitrator_with_activation_costs.get_command(
+                self.time, self.environment_model
+            ),
         )
         self.assertEqual(
             "high_cost",
-            self.test_cost_arbitrator.get_command(self.time, self.environment_model),
+            self.test_cost_arbitrator_with_activation_costs.get_command(
+                self.time, self.environment_model
+            ),
         )
 
     def test_basic_functionality_with_interruptable_options(self):
@@ -407,12 +491,10 @@ def test_basic_functionality_with_interruptable_options(self):
         self.test_cost_arbitrator.add_option(
             self.test_behavior_low_cost,
             ag.CostArbitrator.Option.Flags.INTERRUPTABLE,
-            self.cost_estimator,
         )
         self.test_cost_arbitrator.add_option(
             self.test_behavior_low_cost,
             ag.CostArbitrator.Option.Flags.INTERRUPTABLE,
-            self.cost_estimator,
         )
         self.assertFalse(
             self.test_cost_arbitrator.check_invocation_condition(
@@ -428,12 +510,10 @@ def test_basic_functionality_with_interruptable_options(self):
         self.test_cost_arbitrator.add_option(
             self.test_behavior_high_cost,
             ag.CostArbitrator.Option.Flags.INTERRUPTABLE,
-            self.cost_estimator,
         )
         self.test_cost_arbitrator.add_option(
             self.test_behavior_mid_cost,
             ag.CostArbitrator.Option.Flags.INTERRUPTABLE,
-            self.cost_estimator,
         )
 
         self.assertTrue(
diff --git a/python_bindings/test/test_exceptions.py b/python_bindings/test/test_exceptions.py
index ac8b9be7..25770ad2 100644
--- a/python_bindings/test/test_exceptions.py
+++ b/python_bindings/test/test_exceptions.py
@@ -130,16 +130,14 @@ def test_exceptions_in_cost_arbitrator(self):
 
         t = time.time()
 
-        test_cost_arbitrator = ag.CostArbitrator()
+        test_cost_arbitrator = ag.CostArbitrator("CostArbitrator", cost_estimator)
         test_cost_arbitrator.add_option(
             test_behavior_low_cost,
             ag.CostArbitrator.Option.Flags.NO_FLAGS,
-            cost_estimator,
         )
         test_cost_arbitrator.add_option(
             test_behavior_high_cost,
             ag.CostArbitrator.Option.Flags.NO_FLAGS,
-            cost_estimator,
         )
 
         self.assertTrue(
diff --git a/python_bindings/test/test_nested_arbitrators.py b/python_bindings/test/test_nested_arbitrators.py
index 89cd6d89..c85a1f4a 100644
--- a/python_bindings/test/test_nested_arbitrators.py
+++ b/python_bindings/test/test_nested_arbitrators.py
@@ -34,9 +34,9 @@ def setUp(self):
             DummyCommand("mid_cost"): 0.5,
             DummyCommand("high_cost"): 1,
         }
-        self.cost_estimator = CostEstimatorFromCostMap(cost_map)
+        cost_estimator = CostEstimatorFromCostMap(cost_map)
 
-        self.test_cost_arbitrator = ag.CostArbitrator()
+        self.test_cost_arbitrator = ag.CostArbitrator("CostArbitrator", cost_estimator)
         self.test_priority_arbitrator = ag.PriorityArbitrator()
 
         self.test_root_priority_arbitrator = ag.PriorityArbitrator(
@@ -60,12 +60,10 @@ def test_printout(self):
         self.test_cost_arbitrator.add_option(
             self.test_behavior_low_cost,
             ag.CostArbitrator.Option.Flags.NO_FLAGS,
-            self.cost_estimator,
         )
         self.test_cost_arbitrator.add_option(
             self.test_behavior_high_cost,
             ag.CostArbitrator.Option.Flags.NO_FLAGS,
-            self.cost_estimator,
         )
 
         self.test_priority_arbitrator.add_option(
@@ -109,7 +107,7 @@ def test_printout(self):
             ps.invocation_true + ps.commitment_true + "root priority arbitrator\n" +
             " -> 1. " + ps.invocation_true + ps.commitment_true + "CostArbitrator\n" +
             "        - (cost:  n.a.) " + ps.invocation_false + ps.commitment_false + "low_cost\n" +
-            "     -> - (cost: 1.000) " + ps.invocation_true + ps.commitment_true + "high_cost\n" +
+            "     -> - (cost:  n.a.) " + ps.invocation_true + ps.commitment_true + "high_cost\n" +
             "    2. " + ps.invocation_true + ps.commitment_false + "PriorityArbitrator\n" +
             "        1. " + ps.invocation_false + ps.commitment_false + "HighPriority\n" +
             "        2. " + ps.invocation_true + ps.commitment_true + "LowPriority"
@@ -135,12 +133,10 @@ def test_to_yaml(self):
         self.test_cost_arbitrator.add_option(
             self.test_behavior_low_cost,
             ag.CostArbitrator.Option.Flags.NO_FLAGS,
-            self.cost_estimator,
         )
         self.test_cost_arbitrator.add_option(
             self.test_behavior_high_cost,
             ag.CostArbitrator.Option.Flags.NO_FLAGS,
-            self.cost_estimator,
         )
 
         self.test_priority_arbitrator.add_option(
diff --git a/python_bindings/test/test_verification.py b/python_bindings/test/test_verification.py
index 69eae04a..9ba34111 100644
--- a/python_bindings/test/test_verification.py
+++ b/python_bindings/test/test_verification.py
@@ -263,10 +263,6 @@ def test_dummy_verifier_in_priority_arbitrator_with_fallback(self):
     def test_dummy_verifier_in_cost_arbitrator(self):
         NO_FLAGS = ag.CostArbitrator.Option.Flags.NO_FLAGS
 
-        test_cost_arbitrator = ag.CostArbitrator(
-            "CostArbitrator", DummyVerifier("MidPriority")
-        )
-
         cost_map = {
             DummyCommand("HighPriority"): 0,
             DummyCommand("MidPriority"): 0.5,
@@ -274,19 +270,15 @@ def test_dummy_verifier_in_cost_arbitrator(self):
         }
         cost_estimator = CostEstimatorFromCostMap(cost_map)
 
-        test_cost_arbitrator.add_option(
-            self.test_behavior_high_priority, NO_FLAGS, cost_estimator
-        )
-        test_cost_arbitrator.add_option(
-            self.test_behavior_high_priority, NO_FLAGS, cost_estimator
-        )
-        test_cost_arbitrator.add_option(
-            self.test_behavior_mid_priority, NO_FLAGS, cost_estimator
-        )
-        test_cost_arbitrator.add_option(
-            self.test_behavior_low_priority, NO_FLAGS, cost_estimator
+        test_cost_arbitrator = ag.CostArbitrator(
+            "CostArbitrator", cost_estimator, DummyVerifier("MidPriority")
         )
 
+        test_cost_arbitrator.add_option(self.test_behavior_high_priority, NO_FLAGS)
+        test_cost_arbitrator.add_option(self.test_behavior_high_priority, NO_FLAGS)
+        test_cost_arbitrator.add_option(self.test_behavior_mid_priority, NO_FLAGS)
+        test_cost_arbitrator.add_option(self.test_behavior_low_priority, NO_FLAGS)
+
         self.assertTrue(
             test_cost_arbitrator.check_invocation_condition(
                 self.time, self.environment_model
@@ -325,7 +317,7 @@ def test_dummy_verifier_in_cost_arbitrator(self):
             "    - (cost:  n.a.) " + ps.strike_through_on
                                    + ps.invocation_true + ps.commitment_false + "MidPriority"
                                    + ps.strike_through_off + "\n" +
-            " -> - (cost: 1.000) " + ps.invocation_true + ps.commitment_true + "LowPriority"
+            " -> - (cost:  n.a.) " + ps.invocation_true + ps.commitment_true + "LowPriority"
         )
         # fmt:on
         actual_printout = test_cost_arbitrator.to_string(
diff --git a/test/cost_arbitrator.cpp b/test/cost_arbitrator.cpp
index 614e073b..00a7e294 100644
--- a/test/cost_arbitrator.cpp
+++ b/test/cost_arbitrator.cpp
@@ -22,12 +22,14 @@ class CostArbitratorTest : public ::testing::Test {
     DummyBehavior::Ptr testBehaviorMidCost = std::make_shared<DummyBehavior>(true, false, "mid_cost");
     DummyBehavior::Ptr testBehaviorHighCost = std::make_shared<DummyBehavior>(true, true, "high_cost");
 
-    CostEstimatorFromCostMap::CostMap costMap{{"low_cost", 0}, {"mid_cost", 0.5}, {"high_cost", 1}};
+    CostEstimatorFromCostMap::CostMap costMap{{"low_cost", 0}, {"mid_cost", 0.5}, {"high_cost", 2}};
     CostEstimatorFromCostMap::Ptr costEstimator = std::make_shared<CostEstimatorFromCostMap>(costMap);
     CostEstimatorFromCostMap::Ptr costEstimatorWithActivationCosts =
         std::make_shared<CostEstimatorFromCostMap>(costMap, 10);
 
-    CostArbitrator<DummyEnvironmentModel, DummyCommand> testCostArbitrator;
+    CostArbitrator<DummyEnvironmentModel, DummyCommand> testCostArbitrator{"CostArbitrator", costEstimator};
+    CostArbitrator<DummyEnvironmentModel, DummyCommand> testCostArbitratorWithActivationCosts{
+        "CostArbitrator", costEstimatorWithActivationCosts};
 
     DummyEnvironmentModel environmentModel;
 
@@ -41,13 +43,13 @@ TEST_F(CostArbitratorTest, BasicFunctionality) {
     EXPECT_FALSE(testCostArbitrator.checkCommitmentCondition(time, environmentModel));
 
     // otherwise the invocationCondition is true if any of the option has true invocationCondition
-    testCostArbitrator.addOption(testBehaviorLowCost, OptionFlags::NoFlags, costEstimator);
-    testCostArbitrator.addOption(testBehaviorLowCost, OptionFlags::NoFlags, costEstimator);
+    testCostArbitrator.addOption(testBehaviorLowCost, OptionFlags::NoFlags);
+    testCostArbitrator.addOption(testBehaviorLowCost, OptionFlags::NoFlags);
     EXPECT_FALSE(testCostArbitrator.checkInvocationCondition(time, environmentModel));
     EXPECT_FALSE(testCostArbitrator.checkCommitmentCondition(time, environmentModel));
 
-    testCostArbitrator.addOption(testBehaviorHighCost, OptionFlags::NoFlags, costEstimator);
-    testCostArbitrator.addOption(testBehaviorMidCost, OptionFlags::NoFlags, costEstimator);
+    testCostArbitrator.addOption(testBehaviorHighCost, OptionFlags::NoFlags);
+    testCostArbitrator.addOption(testBehaviorMidCost, OptionFlags::NoFlags);
 
     EXPECT_TRUE(testCostArbitrator.checkInvocationCondition(time, environmentModel));
 
@@ -81,11 +83,49 @@ TEST_F(CostArbitratorTest, BasicFunctionality) {
     EXPECT_EQ("high_cost", testCostArbitrator.getCommand(time, environmentModel));
 }
 
+TEST_F(CostArbitratorTest, DefaultConstructor) {
+    // Use default constructor -> should internally use PlaceboCostEstimator
+    CostArbitrator<DummyEnvironmentModel, DummyCommand> defaultCostArbitrator;
+
+    using OptionFlags = CostArbitrator<DummyEnvironmentModel, DummyCommand>::Option::Flags;
+
+    defaultCostArbitrator.addOption(testBehaviorLowCost, OptionFlags::NoFlags);
+    defaultCostArbitrator.addOption(testBehaviorLowCost, OptionFlags::NoFlags);
+    defaultCostArbitrator.addOption(testBehaviorHighCost, OptionFlags::NoFlags);
+    defaultCostArbitrator.addOption(testBehaviorMidCost, OptionFlags::NoFlags);
+
+    EXPECT_TRUE(defaultCostArbitrator.checkInvocationCondition(time, environmentModel));
+    EXPECT_FALSE(defaultCostArbitrator.checkCommitmentCondition(time, environmentModel));
+
+    defaultCostArbitrator.gainControl(time, environmentModel);
+
+    // With PlaceboCostEstimator:
+    // Costs are assigned by order: 0, 1, 2, ...
+    // low_cost is invalid (invocation=false) and filtered out.
+    // high_cost becomes first valid option → cost 0
+    // mid_cost becomes second valid option → cost 1
+    // => high_cost must win even though mid_cost would normally be cheaper.
+    EXPECT_EQ("high_cost", defaultCostArbitrator.getCommand(time, environmentModel));
+
+    YAML::Node yaml = defaultCostArbitrator.toYaml(time, environmentModel);
+
+    // Verify placebo costs are monotonic starting from 0
+    ASSERT_TRUE(yaml["options"][2]["cost"].IsDefined());
+    ASSERT_TRUE(yaml["options"][3]["cost"].IsDefined());
+
+    EXPECT_NEAR(0.0, yaml["options"][2]["cost"].as<double>(), 1e-6);
+    EXPECT_NEAR(1.0, yaml["options"][3]["cost"].as<double>(), 1e-6);
+
+    // Active behavior should be index 1 (high_cost)
+    ASSERT_TRUE(yaml["activeBehavior"].IsDefined());
+    EXPECT_EQ(2, yaml["activeBehavior"].as<int>());
+}
+
 TEST_F(CostArbitratorTest, CommandCaching) {
-    testCostArbitrator.addOption(testBehaviorLowCost, OptionFlags::NoFlags, costEstimator);
-    testCostArbitrator.addOption(testBehaviorLowCost, OptionFlags::NoFlags, costEstimator);
-    testCostArbitrator.addOption(testBehaviorHighCost, OptionFlags::NoFlags, costEstimator);
-    testCostArbitrator.addOption(testBehaviorMidCost, OptionFlags::NoFlags, costEstimator);
+    testCostArbitrator.addOption(testBehaviorLowCost, OptionFlags::NoFlags);
+    testCostArbitrator.addOption(testBehaviorLowCost, OptionFlags::NoFlags);
+    testCostArbitrator.addOption(testBehaviorHighCost, OptionFlags::NoFlags);
+    testCostArbitrator.addOption(testBehaviorMidCost, OptionFlags::NoFlags);
 
     EXPECT_TRUE(testCostArbitrator.checkInvocationCondition(time, environmentModel));
     EXPECT_FALSE(testCostArbitrator.checkCommitmentCondition(time, environmentModel));
@@ -112,10 +152,10 @@ TEST_F(CostArbitratorTest, CommandCaching) {
 }
 
 TEST_F(CostArbitratorTest, Printout) {
-    testCostArbitrator.addOption(testBehaviorLowCost, OptionFlags::NoFlags, costEstimator);
-    testCostArbitrator.addOption(testBehaviorLowCost, OptionFlags::NoFlags, costEstimator);
-    testCostArbitrator.addOption(testBehaviorHighCost, OptionFlags::NoFlags, costEstimator);
-    testCostArbitrator.addOption(testBehaviorMidCost, OptionFlags::NoFlags, costEstimator);
+    testCostArbitrator.addOption(testBehaviorLowCost, OptionFlags::NoFlags);
+    testCostArbitrator.addOption(testBehaviorLowCost, OptionFlags::NoFlags);
+    testCostArbitrator.addOption(testBehaviorHighCost, OptionFlags::NoFlags);
+    testCostArbitrator.addOption(testBehaviorMidCost, OptionFlags::NoFlags);
 
     // clang-format off
     std::string expectedPrintout = InvocationTrueString + CommitmentFalseString + "CostArbitrator\n"
@@ -137,7 +177,7 @@ TEST_F(CostArbitratorTest, Printout) {
     expectedPrintout = InvocationTrueString + CommitmentTrueString + "CostArbitrator\n"
                         "    - (cost:  n.a.) " + InvocationFalseString + CommitmentFalseString + "low_cost\n"
                         "    - (cost:  n.a.) " + InvocationFalseString + CommitmentFalseString + "low_cost\n"
-                        "    - (cost: 1.000) " + InvocationTrueString + CommitmentTrueString + "high_cost\n"
+                        "    - (cost: 2.000) " + InvocationTrueString + CommitmentTrueString + "high_cost\n"
                         " -> - (cost: 0.500) " + InvocationTrueString + CommitmentFalseString + "mid_cost";
     // clang-format on
     actualPrintout = testCostArbitrator.toString(time, environmentModel);
@@ -147,10 +187,10 @@ TEST_F(CostArbitratorTest, Printout) {
 }
 
 TEST_F(CostArbitratorTest, ToYaml) {
-    testCostArbitrator.addOption(testBehaviorLowCost, OptionFlags::NoFlags, costEstimator);
-    testCostArbitrator.addOption(testBehaviorLowCost, OptionFlags::NoFlags, costEstimator);
-    testCostArbitrator.addOption(testBehaviorHighCost, OptionFlags::NoFlags, costEstimator);
-    testCostArbitrator.addOption(testBehaviorMidCost, OptionFlags::NoFlags, costEstimator);
+    testCostArbitrator.addOption(testBehaviorLowCost, OptionFlags::NoFlags);
+    testCostArbitrator.addOption(testBehaviorLowCost, OptionFlags::NoFlags);
+    testCostArbitrator.addOption(testBehaviorHighCost, OptionFlags::NoFlags);
+    testCostArbitrator.addOption(testBehaviorMidCost, OptionFlags::NoFlags);
 
     YAML::Node yaml = testCostArbitrator.toYaml(time, environmentModel);
 
@@ -195,7 +235,7 @@ TEST_F(CostArbitratorTest, ToYaml) {
     EXPECT_EQ(false, yaml["options"][1]["cost"].IsDefined());
     ASSERT_EQ(true, yaml["options"][2]["cost"].IsDefined());
     ASSERT_EQ(true, yaml["options"][3]["cost"].IsDefined());
-    EXPECT_NEAR(1.0, yaml["options"][2]["cost"].as<double>(), 1e-3);
+    EXPECT_NEAR(2.0, yaml["options"][2]["cost"].as<double>(), 1e-3);
     EXPECT_NEAR(0.5, yaml["options"][3]["cost"].as<double>(), 1e-3);
 
     ASSERT_EQ(true, yaml["activeBehavior"].IsDefined());
@@ -203,41 +243,64 @@ TEST_F(CostArbitratorTest, ToYaml) {
 }
 
 
+TEST_F(CostArbitratorTest, BatchCostEstimator) {
+    auto batchEstimator = std::make_shared<ScaledCostEstimatorFromCostMap>(costMap);
+    CostArbitrator<DummyEnvironmentModel, DummyCommand> batchArbitrator{"CostArbitrator", batchEstimator};
+
+    batchArbitrator.addOption(testBehaviorLowCost, OptionFlags::NoFlags);
+    batchArbitrator.addOption(testBehaviorLowCost, OptionFlags::NoFlags);
+    batchArbitrator.addOption(testBehaviorHighCost, OptionFlags::NoFlags);
+    batchArbitrator.addOption(testBehaviorMidCost, OptionFlags::NoFlags);
+
+    batchArbitrator.gainControl(time, environmentModel);
+    EXPECT_EQ("mid_cost", batchArbitrator.getCommand(time, environmentModel));
+
+    YAML::Node yaml = batchArbitrator.toYaml(time, environmentModel);
+
+
+    ASSERT_EQ(true, yaml["options"][2]["cost"].IsDefined());
+    ASSERT_EQ(true, yaml["options"][3]["cost"].IsDefined());
+    // The costs are scaled to [0,1] in this estimator
+    EXPECT_NEAR(1.0, yaml["options"][2]["cost"].as<double>(), 1e-3);
+    EXPECT_NEAR(0.25, yaml["options"][3]["cost"].as<double>(), 1e-3);
+}
+
+
 TEST_F(CostArbitratorTest, BasicFunctionalityWithInterruptableOptionsAndActivationCosts) {
     // if there are no options yet -> the invocationCondition should be false
-    EXPECT_FALSE(testCostArbitrator.checkInvocationCondition(time, environmentModel));
-    EXPECT_FALSE(testCostArbitrator.checkCommitmentCondition(time, environmentModel));
+    EXPECT_FALSE(testCostArbitratorWithActivationCosts.checkInvocationCondition(time, environmentModel));
+    EXPECT_FALSE(testCostArbitratorWithActivationCosts.checkCommitmentCondition(time, environmentModel));
 
     // otherwise the invocationCondition is true if any of the option has true invocationCondition
-    testCostArbitrator.addOption(testBehaviorLowCost, OptionFlags::Interruptable, costEstimatorWithActivationCosts);
-    testCostArbitrator.addOption(testBehaviorLowCost, OptionFlags::Interruptable, costEstimatorWithActivationCosts);
-    EXPECT_FALSE(testCostArbitrator.checkInvocationCondition(time, environmentModel));
-    EXPECT_FALSE(testCostArbitrator.checkCommitmentCondition(time, environmentModel));
+    testCostArbitratorWithActivationCosts.addOption(testBehaviorLowCost, OptionFlags::Interruptable);
+    testCostArbitratorWithActivationCosts.addOption(testBehaviorLowCost, OptionFlags::Interruptable);
+    EXPECT_FALSE(testCostArbitratorWithActivationCosts.checkInvocationCondition(time, environmentModel));
+    EXPECT_FALSE(testCostArbitratorWithActivationCosts.checkCommitmentCondition(time, environmentModel));
 
-    testCostArbitrator.addOption(testBehaviorHighCost, OptionFlags::Interruptable, costEstimatorWithActivationCosts);
-    testCostArbitrator.addOption(testBehaviorMidCost, OptionFlags::Interruptable, costEstimatorWithActivationCosts);
+    testCostArbitratorWithActivationCosts.addOption(testBehaviorHighCost, OptionFlags::Interruptable);
+    testCostArbitratorWithActivationCosts.addOption(testBehaviorMidCost, OptionFlags::Interruptable);
 
-    EXPECT_TRUE(testCostArbitrator.checkInvocationCondition(time, environmentModel));
+    EXPECT_TRUE(testCostArbitratorWithActivationCosts.checkInvocationCondition(time, environmentModel));
 
-    EXPECT_FALSE(testCostArbitrator.checkCommitmentCondition(time, environmentModel));
+    EXPECT_FALSE(testCostArbitratorWithActivationCosts.checkCommitmentCondition(time, environmentModel));
 
-    testCostArbitrator.gainControl(time, environmentModel);
-    EXPECT_EQ("mid_cost", testCostArbitrator.getCommand(time, environmentModel));
+    testCostArbitratorWithActivationCosts.gainControl(time, environmentModel);
+    EXPECT_EQ("mid_cost", testCostArbitratorWithActivationCosts.getCommand(time, environmentModel));
 
-    EXPECT_EQ("mid_cost", testCostArbitrator.getCommand(time, environmentModel));
+    EXPECT_EQ("mid_cost", testCostArbitratorWithActivationCosts.getCommand(time, environmentModel));
 
     testBehaviorMidCost->invocationCondition = false;
-    EXPECT_TRUE(testCostArbitrator.checkInvocationCondition(time, environmentModel));
-    EXPECT_TRUE(testCostArbitrator.checkCommitmentCondition(time, environmentModel));
-    EXPECT_EQ("high_cost", testCostArbitrator.getCommand(time, environmentModel));
-    EXPECT_EQ("high_cost", testCostArbitrator.getCommand(time, environmentModel));
+    EXPECT_TRUE(testCostArbitratorWithActivationCosts.checkInvocationCondition(time, environmentModel));
+    EXPECT_TRUE(testCostArbitratorWithActivationCosts.checkCommitmentCondition(time, environmentModel));
+    EXPECT_EQ("high_cost", testCostArbitratorWithActivationCosts.getCommand(time, environmentModel));
+    EXPECT_EQ("high_cost", testCostArbitratorWithActivationCosts.getCommand(time, environmentModel));
 
     // high_cost behavior is not interruptable -> high_cost should stay active
     testBehaviorMidCost->invocationCondition = true;
-    EXPECT_TRUE(testCostArbitrator.checkInvocationCondition(time, environmentModel));
-    EXPECT_TRUE(testCostArbitrator.checkCommitmentCondition(time, environmentModel));
-    EXPECT_EQ("high_cost", testCostArbitrator.getCommand(time, environmentModel));
-    EXPECT_EQ("high_cost", testCostArbitrator.getCommand(time, environmentModel));
+    EXPECT_TRUE(testCostArbitratorWithActivationCosts.checkInvocationCondition(time, environmentModel));
+    EXPECT_TRUE(testCostArbitratorWithActivationCosts.checkCommitmentCondition(time, environmentModel));
+    EXPECT_EQ("high_cost", testCostArbitratorWithActivationCosts.getCommand(time, environmentModel));
+    EXPECT_EQ("high_cost", testCostArbitratorWithActivationCosts.getCommand(time, environmentModel));
 }
 
 
@@ -247,13 +310,13 @@ TEST_F(CostArbitratorTest, BasicFunctionalityWithInterruptableOptions) {
     EXPECT_FALSE(testCostArbitrator.checkCommitmentCondition(time, environmentModel));
 
     // otherwise the invocationCondition is true if any of the option has true invocationCondition
-    testCostArbitrator.addOption(testBehaviorLowCost, OptionFlags::Interruptable, costEstimator);
-    testCostArbitrator.addOption(testBehaviorLowCost, OptionFlags::Interruptable, costEstimator);
+    testCostArbitrator.addOption(testBehaviorLowCost, OptionFlags::Interruptable);
+    testCostArbitrator.addOption(testBehaviorLowCost, OptionFlags::Interruptable);
     EXPECT_FALSE(testCostArbitrator.checkInvocationCondition(time, environmentModel));
     EXPECT_FALSE(testCostArbitrator.checkCommitmentCondition(time, environmentModel));
 
-    testCostArbitrator.addOption(testBehaviorHighCost, OptionFlags::Interruptable, costEstimator);
-    testCostArbitrator.addOption(testBehaviorMidCost, OptionFlags::Interruptable, costEstimator);
+    testCostArbitrator.addOption(testBehaviorHighCost, OptionFlags::Interruptable);
+    testCostArbitrator.addOption(testBehaviorMidCost, OptionFlags::Interruptable);
 
     EXPECT_TRUE(testCostArbitrator.checkInvocationCondition(time, environmentModel));
 
@@ -290,12 +353,13 @@ TEST(CostArbitrator, SubCommandTypeDiffersFromCommandType) {
     CostEstimatorFromCostMap::CostMap costMap{{"low_cost", 0}, {"__mid_cost__", 0.5}, {"____high_cost____", 1}};
     CostEstimatorFromCostMap::Ptr costEstimator = std::make_shared<CostEstimatorFromCostMap>(costMap);
 
-    CostArbitrator<DummyEnvironmentModel, DummyCommandInt, DummyCommand> testCostArbitrator;
+    CostArbitrator<DummyEnvironmentModel, DummyCommandInt, DummyCommand> testCostArbitrator{"CostArbitrator",
+                                                                                            costEstimator};
 
-    testCostArbitrator.addOption(testBehaviorLowCost, OptionFlags::Interruptable, costEstimator);
-    testCostArbitrator.addOption(testBehaviorLowCost, OptionFlags::Interruptable, costEstimator);
-    testCostArbitrator.addOption(testBehaviorHighCost, OptionFlags::Interruptable, costEstimator);
-    testCostArbitrator.addOption(testBehaviorMidCost, OptionFlags::Interruptable, costEstimator);
+    testCostArbitrator.addOption(testBehaviorLowCost, OptionFlags::Interruptable);
+    testCostArbitrator.addOption(testBehaviorLowCost, OptionFlags::Interruptable);
+    testCostArbitrator.addOption(testBehaviorHighCost, OptionFlags::Interruptable);
+    testCostArbitrator.addOption(testBehaviorMidCost, OptionFlags::Interruptable);
 
     testCostArbitrator.gainControl(time, environmentModel);
 
diff --git a/test/cost_estimator.hpp b/test/cost_estimator.hpp
index 8017756e..89cf059d 100644
--- a/test/cost_estimator.hpp
+++ b/test/cost_estimator.hpp
@@ -1,6 +1,8 @@
 #pragma once
 
+#include <map>
 #include <utility>
+#include <vector>
 
 #include "cost_arbitrator.hpp"
 
@@ -42,4 +44,54 @@ struct CostEstimatorFromCostMap : public CostEstimator<DummyEnvironmentModel, Du
     double activationCosts_;
 };
 
+struct ScaledCostEstimatorFromCostMap : public BatchCostEstimator<DummyEnvironmentModel, DummyCommand> {
+    using CandidateT = typename BatchCostEstimator<DummyEnvironmentModel, DummyCommand>::Candidate;
+    using CostMap = std::map<DummyCommand, double>;
+
+    explicit ScaledCostEstimatorFromCostMap(CostMap costMap) : costMap_(std::move(costMap)) {
+    }
+    ScaledCostEstimatorFromCostMap(const ScaledCostEstimatorFromCostMap&) = default;
+    ScaledCostEstimatorFromCostMap(ScaledCostEstimatorFromCostMap&&) = default;
+    ScaledCostEstimatorFromCostMap& operator=(const ScaledCostEstimatorFromCostMap&) = default;
+    ScaledCostEstimatorFromCostMap& operator=(ScaledCostEstimatorFromCostMap&&) = default;
+    virtual ~ScaledCostEstimatorFromCostMap() = default;
+
+    std::vector<double> estimateCosts(const Time& /*time*/,
+                                      const DummyEnvironmentModel& environmentModel,
+                                      const std::vector<CandidateT>& candidates) override {
+        // If the access to the environment model is expensive, batch-wise processing can help reduce the overhead.
+        environmentModel.getObservation();
+
+        std::vector<double> rawCosts;
+        rawCosts.reserve(candidates.size());
+        for (const auto& candidate : candidates) {
+            rawCosts.push_back(costMap_.at(candidate.command));
+        }
+
+        if (rawCosts.empty()) {
+            return {};
+        }
+
+        // Compute max cost in the batch
+        double maxCost = *std::max_element(rawCosts.begin(), rawCosts.end());
+
+        std::vector<double> scaledCosts;
+        scaledCosts.reserve(candidates.size());
+
+        if (maxCost == 0.0) {
+            scaledCosts.assign(rawCosts.size(), 0.0);
+            return scaledCosts;
+        }
+
+        for (double cost : rawCosts) {
+            scaledCosts.push_back(cost / maxCost);
+        }
+
+        return scaledCosts;
+    }
+
+private:
+    CostMap costMap_;
+};
+
 } // namespace arbitration_graphs_tests
diff --git a/test/handle_exceptions.cpp b/test/handle_exceptions.cpp
index 608f7703..e3436170 100644
--- a/test/handle_exceptions.cpp
+++ b/test/handle_exceptions.cpp
@@ -99,10 +99,10 @@ TEST_F(ExceptionHandlingTest, HandleExceptionsInCostArbitrator) {
 
     Time time{Clock::now()};
 
-    CostArbitrator<DummyEnvironmentModel, DummyCommand> testCostArbitrator;
+    CostArbitrator<DummyEnvironmentModel, DummyCommand> testCostArbitrator{"CostArbitrator", costEstimator};
 
-    testCostArbitrator.addOption(testBehaviorLowCost, OptionFlags::NoFlags, costEstimator);
-    testCostArbitrator.addOption(testBehaviorHighCost, OptionFlags::NoFlags, costEstimator);
+    testCostArbitrator.addOption(testBehaviorLowCost, OptionFlags::NoFlags);
+    testCostArbitrator.addOption(testBehaviorHighCost, OptionFlags::NoFlags);
 
     ASSERT_TRUE(testCostArbitrator.checkInvocationCondition(time, environmentModel));
 
diff --git a/test/nested_arbitrators.cpp b/test/nested_arbitrators.cpp
index c323d326..979c9c91 100644
--- a/test/nested_arbitrators.cpp
+++ b/test/nested_arbitrators.cpp
@@ -33,7 +33,7 @@ class NestedArbitratorsTest : public ::testing::Test {
     CostEstimatorFromCostMap::CostMap costMap{{"low_cost", 0}, {"mid_cost", 0.5}, {"high_cost", 1}};
     CostEstimatorFromCostMap::Ptr costEstimator = std::make_shared<CostEstimatorFromCostMap>(costMap);
 
-    CostArbitratorT::Ptr testCostArbitrator = std::make_shared<CostArbitratorT>();
+    CostArbitratorT::Ptr testCostArbitrator = std::make_shared<CostArbitratorT>("CostArbitrator", costEstimator);
     PriorityArbitratorT::Ptr testPriorityArbitrator = std::make_shared<PriorityArbitratorT>();
 
     PriorityArbitratorT::Ptr testRootPriorityArbitrator =
@@ -48,8 +48,8 @@ TEST_F(NestedArbitratorsTest, Printout) {
     testRootPriorityArbitrator->addOption(testCostArbitrator, PriorityOptionFlags::NoFlags);
     testRootPriorityArbitrator->addOption(testPriorityArbitrator, PriorityOptionFlags::NoFlags);
 
-    testCostArbitrator->addOption(testBehaviorLowCost, CostOptionFlags::NoFlags, costEstimator);
-    testCostArbitrator->addOption(testBehaviorHighCost, CostOptionFlags::NoFlags, costEstimator);
+    testCostArbitrator->addOption(testBehaviorLowCost, CostOptionFlags::NoFlags);
+    testCostArbitrator->addOption(testBehaviorHighCost, CostOptionFlags::NoFlags);
 
     testPriorityArbitrator->addOption(testBehaviorHighPriority, PriorityOptionFlags::NoFlags);
     testPriorityArbitrator->addOption(testBehaviorLowPriority, PriorityOptionFlags::NoFlags);
@@ -83,7 +83,7 @@ TEST_F(NestedArbitratorsTest, Printout) {
     expectedPrintout = InvocationTrueString + CommitmentTrueString + "root priority arbitrator\n"
                         " -> 1. "  + InvocationTrueString + CommitmentTrueString + "CostArbitrator\n"
                         "        - (cost:  n.a.) " + InvocationFalseString + CommitmentFalseString + "low_cost\n"
-                        "     -> - (cost: 1.000) " + InvocationTrueString + CommitmentTrueString + "high_cost\n"
+                        "     -> - (cost:  n.a.) " + InvocationTrueString + CommitmentTrueString + "high_cost\n"
                         "    2. " + InvocationTrueString + CommitmentFalseString + "PriorityArbitrator\n"
                         "        1. " + InvocationFalseString + CommitmentFalseString + "HighPriority\n"
                         "        2. " + InvocationTrueString + CommitmentTrueString + "LowPriority";
@@ -99,8 +99,8 @@ TEST_F(NestedArbitratorsTest, ToYaml) {
     testRootPriorityArbitrator->addOption(testCostArbitrator, PriorityOptionFlags::NoFlags);
     testRootPriorityArbitrator->addOption(testPriorityArbitrator, PriorityOptionFlags::NoFlags);
 
-    testCostArbitrator->addOption(testBehaviorLowCost, CostOptionFlags::NoFlags, costEstimator);
-    testCostArbitrator->addOption(testBehaviorHighCost, CostOptionFlags::NoFlags, costEstimator);
+    testCostArbitrator->addOption(testBehaviorLowCost, CostOptionFlags::NoFlags);
+    testCostArbitrator->addOption(testBehaviorHighCost, CostOptionFlags::NoFlags);
 
     testPriorityArbitrator->addOption(testBehaviorHighPriority, PriorityOptionFlags::NoFlags);
     testPriorityArbitrator->addOption(testBehaviorLowPriority, PriorityOptionFlags::NoFlags);
diff --git a/test/verification.cpp b/test/verification.cpp
index 763d9067..e9a67fab 100644
--- a/test/verification.cpp
+++ b/test/verification.cpp
@@ -222,16 +222,16 @@ TEST_F(CommandVerificationTest, DummyVerifierInPriorityArbitratorWithFallback) {
 TEST_F(CommandVerificationTest, DummyVerifierInCostArbitrator) {
     using OptionFlags = CostArbitrator<DummyEnvironmentModel, DummyCommand>::Option::Flags;
 
-    CostArbitrator<DummyEnvironmentModel, DummyCommand> testCostArbitrator("CostArbitrator",
-                                                                           std::make_shared<DummyVerifier>());
-
     CostEstimatorFromCostMap::CostMap costMap{{"HighPriority", 0}, {"MidPriority", 0.5}, {"LowPriority", 1}};
     CostEstimatorFromCostMap::Ptr costEstimator = std::make_shared<CostEstimatorFromCostMap>(costMap);
 
-    testCostArbitrator.addOption(testBehaviorHighPriority, OptionFlags::NoFlags, costEstimator);
-    testCostArbitrator.addOption(testBehaviorHighPriority, OptionFlags::NoFlags, costEstimator);
-    testCostArbitrator.addOption(testBehaviorMidPriority, OptionFlags::NoFlags, costEstimator);
-    testCostArbitrator.addOption(testBehaviorLowPriority, OptionFlags::NoFlags, costEstimator);
+    CostArbitrator<DummyEnvironmentModel, DummyCommand> testCostArbitrator(
+        "CostArbitrator", costEstimator, std::make_shared<DummyVerifier>());
+
+    testCostArbitrator.addOption(testBehaviorHighPriority, OptionFlags::NoFlags);
+    testCostArbitrator.addOption(testBehaviorHighPriority, OptionFlags::NoFlags);
+    testCostArbitrator.addOption(testBehaviorMidPriority, OptionFlags::NoFlags);
+    testCostArbitrator.addOption(testBehaviorLowPriority, OptionFlags::NoFlags);
 
     ASSERT_TRUE(testCostArbitrator.checkInvocationCondition(time, environmentModel));
 
@@ -253,7 +253,7 @@ TEST_F(CommandVerificationTest, DummyVerifierInCostArbitrator) {
                         "    - (cost:  n.a.) " + StrikeThroughOn
                                   + InvocationTrueString + CommitmentFalseString + "MidPriority"
                                   + StrikeThroughOff + "\n"
-                        " -> - (cost: 1.000) " + InvocationTrueString + CommitmentTrueString + "LowPriority";
+                        " -> - (cost:  n.a.) " + InvocationTrueString + CommitmentTrueString + "LowPriority";
     // clang-format on
     std::string actualPrintout = testCostArbitrator.toString(time, environmentModel);
     std::cout << actualPrintout << '\n';