diff --git a/bofire/data_models/acquisition_functions/acquisition_function.py b/bofire/data_models/acquisition_functions/acquisition_function.py
index 74772ef05..bb0b55495 100644
--- a/bofire/data_models/acquisition_functions/acquisition_function.py
+++ b/bofire/data_models/acquisition_functions/acquisition_function.py
@@ -9,31 +9,63 @@ class AcquisitionFunction(BaseModel):
     type: str
 
 
-class qNEI(AcquisitionFunction):
+class SingleObjectiveAcquisitionFunction(AcquisitionFunction):
+    type: str
+
+
+class MultiObjectiveAcquisitionFunction(AcquisitionFunction):
+    type: str
+
+
+class qNEI(SingleObjectiveAcquisitionFunction):
     type: Literal["qNEI"] = "qNEI"
+    prune_baseline: bool = True
 
 
-class qLogNEI(AcquisitionFunction):
+class qLogNEI(SingleObjectiveAcquisitionFunction):
     type: Literal["qLogNEI"] = "qLogNEI"
+    prune_baseline: bool = True
 
 
-class qEI(AcquisitionFunction):
+class qEI(SingleObjectiveAcquisitionFunction):
     type: Literal["qEI"] = "qEI"
 
 
-class qLogEI(AcquisitionFunction):
+class qLogEI(SingleObjectiveAcquisitionFunction):
     type: Literal["qLogEI"] = "qLogEI"
 
 
-class qSR(AcquisitionFunction):
+class qSR(SingleObjectiveAcquisitionFunction):
     type: Literal["qSR"] = "qSR"
 
 
-class qUCB(AcquisitionFunction):
+class qUCB(SingleObjectiveAcquisitionFunction):
     type: Literal["qUCB"] = "qUCB"
     beta: Annotated[float, Field(ge=0)] = 0.2
 
 
-class qPI(AcquisitionFunction):
+class qPI(SingleObjectiveAcquisitionFunction):
     type: Literal["qPI"] = "qPI"
     tau: PositiveFloat = 1e-3
+
+
+class qEHVI(MultiObjectiveAcquisitionFunction):
+    type: Literal["qEHVI"] = "qEHVI"
+    alpha: Annotated[float, Field(ge=0)] = 0.0
+
+
+class qLogEHVI(MultiObjectiveAcquisitionFunction):
+    type: Literal["qLogEHVI"] = "qLogEHVI"
+    alpha: Annotated[float, Field(ge=0)] = 0.0
+
+
+class qNEHVI(MultiObjectiveAcquisitionFunction):
+    type: Literal["qNEHVI"] = "qNEHVI"
+    alpha: Annotated[float, Field(ge=0)] = 0.0
+    prune_baseline: bool = True
+
+
+class qLogNEHVI(MultiObjectiveAcquisitionFunction):
+    type: Literal["qLogNEHVI"] = "qLogNEHVI"
+    alpha: Annotated[float, Field(ge=0)] = 0.0
+    prune_baseline: bool = True
diff --git a/bofire/data_models/acquisition_functions/api.py b/bofire/data_models/acquisition_functions/api.py
index ebfce13e9..b1ea501ca 100644
--- a/bofire/data_models/acquisition_functions/api.py
+++ b/bofire/data_models/acquisition_functions/api.py
@@ -2,15 +2,33 @@
 
 from bofire.data_models.acquisition_functions.acquisition_function import (
     AcquisitionFunction,
+    MultiObjectiveAcquisitionFunction,
+    SingleObjectiveAcquisitionFunction,
+    qEHVI,
     qEI,
+    qLogEHVI,
     qLogEI,
+    qLogNEHVI,
     qLogNEI,
+    qNEHVI,
     qNEI,
     qPI,
     qSR,
     qUCB,
 )
 
-AbstractAcquisitionFunction = AcquisitionFunction
+AbstractAcquisitionFunction = [
+    AcquisitionFunction,
+    SingleObjectiveAcquisitionFunction,
+    MultiObjectiveAcquisitionFunction,
+]
+
+AnyAcquisitionFunction = Union[
+    qNEI, qEI, qSR, qUCB, qPI, qLogEI, qLogNEI, qEHVI, qLogEHVI, qNEHVI, qLogNEHVI
+]
+
+AnySingleObjectiveAcquisitionFunction = Union[
+    qNEI, qEI, qSR, qUCB, qPI, qLogEI, qLogNEI
+]
 
-AnyAcquisitionFunction = Union[qNEI, qEI, qSR, qUCB, qPI, qLogEI, qLogNEI]
+AnyMultiObjectiveAcquisitionFunction = Union[qEHVI, qLogEHVI, qNEHVI, qLogNEHVI]
diff --git a/bofire/data_models/strategies/api.py b/bofire/data_models/strategies/api.py
index 85cc824da..46690244e 100644
--- a/bofire/data_models/strategies/api.py
+++ b/bofire/data_models/strategies/api.py
@@ -3,6 +3,7 @@
 from bofire.data_models.strategies.doe import DoEStrategy
 from bofire.data_models.strategies.factorial import FactorialStrategy
 from bofire.data_models.strategies.predictives.botorch import BotorchStrategy
+from bofire.data_models.strategies.predictives.mobo import MoboStrategy
 from bofire.data_models.strategies.predictives.multiobjective import (
     MultiobjectiveStrategy,
 )
@@ -53,6 +54,7 @@
     DoEStrategy,
     StepwiseStrategy,
     FactorialStrategy,
+    MoboStrategy,
 ]
 
 AnyPredictive = Union[
@@ -63,6 +65,7 @@
     QehviStrategy,
     QnehviStrategy,
     QparegoStrategy,
+    MoboStrategy,
 ]
 
 AnySampler = Union[PolytopeSampler, RejectionSampler]
diff --git a/bofire/data_models/strategies/predictives/mobo.py b/bofire/data_models/strategies/predictives/mobo.py
new file mode 100644
index 000000000..9ce33b0a7
--- /dev/null
+++ b/bofire/data_models/strategies/predictives/mobo.py
@@ -0,0 +1,76 @@
+from typing import Dict, Literal, Optional, Type
+
+from pydantic import Field, validator
+
+from bofire.data_models.acquisition_functions.api import (
+    AnyMultiObjectiveAcquisitionFunction,
+    qLogNEHVI,
+)
+from bofire.data_models.features.api import CategoricalOutput, Feature
+from bofire.data_models.objectives.api import (
+    CloseToTargetObjective,
+    MaximizeObjective,
+    MaximizeSigmoidObjective,
+    MinimizeObjective,
+    MinimizeSigmoidObjective,
+    Objective,
+    TargetObjective,
+)
+from bofire.data_models.strategies.predictives.multiobjective import (
+    MultiobjectiveStrategy,
+)
+
+
+class MoboStrategy(MultiobjectiveStrategy):
+    type: Literal["MoboStrategy"] = "MoboStrategy"
+    ref_point: Optional[Dict[str, float]] = None
+    acquisition_function: AnyMultiObjectiveAcquisitionFunction = Field(
+        default_factory=lambda: qLogNEHVI()
+    )
+
+    @validator("ref_point")
+    def validate_ref_point(cls, v, values):
+        """Validate that the provided refpoint matches the provided domain."""
+        if v is None:
+            return v
+        keys = values["domain"].outputs.get_keys_by_objective(
+            [MaximizeObjective, MinimizeObjective]
+        )
+        if sorted(keys) != sorted(v.keys()):
+            raise ValueError(
+                f"Provided refpoint do not match the domain, expected keys: {keys}"
+            )
+        return v
+
+    @classmethod
+    def is_feature_implemented(cls, my_type: Type[Feature]) -> bool:
+        """Method to check if a specific feature type is implemented for the strategy
+
+        Args:
+            my_type (Type[Feature]): Feature class
+
+        Returns:
+            bool: True if the feature type is valid for the strategy chosen, False otherwise
+        """
+        if my_type not in [CategoricalOutput]:
+            return True
+        return False
+
+    @classmethod
+    def is_objective_implemented(cls, my_type: Type[Objective]) -> bool:
+        """Method to check if a objective type is implemented for the strategy
+
+        Args:
+            my_type (Type[Objective]): Objective class
+
+        Returns:
+            bool: True if the objective type is valid for the strategy chosen, False otherwise
+        """
+        return my_type in [
+            MaximizeObjective,
+            MinimizeObjective,
+            MinimizeSigmoidObjective,
+            MaximizeSigmoidObjective,
+            TargetObjective,
+            CloseToTargetObjective,
+        ]
diff --git a/bofire/data_models/strategies/predictives/sobo.py b/bofire/data_models/strategies/predictives/sobo.py
index 052a6bf91..54056473a 100644
--- a/bofire/data_models/strategies/predictives/sobo.py
+++ b/bofire/data_models/strategies/predictives/sobo.py
@@ -2,14 +2,19 @@
 
 from pydantic import Field, validator
 
-from bofire.data_models.acquisition_functions.api import AnyAcquisitionFunction, qNEI
+from bofire.data_models.acquisition_functions.api import (
+    AnySingleObjectiveAcquisitionFunction,
+    qLogNEI,
+)
 from bofire.data_models.features.api import CategoricalOutput, Feature
 from bofire.data_models.objectives.api import ConstrainedObjective, Objective
 from bofire.data_models.strategies.predictives.botorch import BotorchStrategy
 
 
 class SoboBaseStrategy(BotorchStrategy):
-    acquisition_function: AnyAcquisitionFunction = Field(default_factory=lambda: qNEI())
+    acquisition_function: AnySingleObjectiveAcquisitionFunction = Field(
+        default_factory=lambda: qLogNEI()
+    )
 
     @classmethod
     def is_feature_implemented(cls, my_type: Type[Feature]) -> bool:
diff --git a/bofire/strategies/mapper.py b/bofire/strategies/mapper.py
index d3db33f24..338082ec6 100644
--- a/bofire/strategies/mapper.py
+++ b/bofire/strategies/mapper.py
@@ -4,6 +4,7 @@
 from bofire.strategies.doe_strategy import DoEStrategy  # noqa: F401
 from bofire.strategies.factorial import FactorialStrategy
 from bofire.strategies.predictives.botorch import BotorchStrategy  # noqa: F401
+from bofire.strategies.predictives.mobo import MoboStrategy
 from bofire.strategies.predictives.predictive import PredictiveStrategy  # noqa: F401
 from bofire.strategies.predictives.qehvi import QehviStrategy  # noqa: F401
 from bofire.strategies.predictives.qnehvi import QnehviStrategy  # noqa: F401
@@ -35,6 +36,7 @@
     data_models.DoEStrategy: DoEStrategy,
     data_models.StepwiseStrategy: StepwiseStrategy,
     data_models.FactorialStrategy: FactorialStrategy,
+    data_models.MoboStrategy: MoboStrategy,
 }
 
 
diff --git a/bofire/strategies/predictives/mobo.py b/bofire/strategies/predictives/mobo.py
new file mode 100644
index 000000000..a7d1a547b
--- /dev/null
+++ b/bofire/strategies/predictives/mobo.py
@@ -0,0 +1,161 @@
+from typing import List, Optional
+
+import numpy as np
+import torch
+from botorch.acquisition import AcquisitionFunction, get_acquisition_function
+from botorch.acquisition.multi_objective.objective import (
+    GenericMCMultiOutputObjective,
+    MCMultiOutputObjective,
+)
+from botorch.models.gpytorch import GPyTorchModel
+
+from bofire.data_models.acquisition_functions.api import (
+    qEHVI,
+    qLogEHVI,
+    qLogNEHVI,
+    qNEHVI,
+)
+from bofire.data_models.objectives.api import ConstrainedObjective
+from bofire.data_models.strategies.api import MoboStrategy as DataModel
+from bofire.strategies.predictives.botorch import BotorchStrategy
+from bofire.utils.multiobjective import get_ref_point_mask, infer_ref_point
+from bofire.utils.torch_tools import (
+    get_multiobjective_objective,
+    get_output_constraints,
+    tkwargs,
+)
+
+
+class MoboStrategy(BotorchStrategy):
+    def __init__(
+        self,
+        data_model: DataModel,
+        **kwargs,
+    ):
+        super().__init__(data_model=data_model, **kwargs)
+        self.ref_point = data_model.ref_point
+        self.ref_point_mask = get_ref_point_mask(self.domain)
+        self.acquisition_function = data_model.acquisition_function
+
+    ref_point: Optional[dict] = None
+    objective: Optional[MCMultiOutputObjective] = None
+
+    def _get_acqfs(self, n) -> List[AcquisitionFunction]:
+        assert self.is_fitted is True, "Model not trained."
+
+        X_train, X_pending = self.get_acqf_input_tensors()
+
+        # get etas and constraints
+        constraints, etas = get_output_constraints(self.domain.outputs)
+        if len(constraints) == 0:
+            constraints, etas = None, 1e-3
+        else:
+            etas = torch.tensor(etas).to(**tkwargs)
+
+        objective = self._get_objective()
+        # in case that qehvi, qlogehvi is used we need also y
+        if isinstance(self.acquisition_function, (qLogEHVI, qEHVI)):
+            Y = torch.from_numpy(
+                self.domain.outputs.preprocess_experiments_all_valid_outputs(
+                    self.experiments
+                )[self.domain.outputs.get_keys()].values
+            ).to(**tkwargs)
+        else:
+            Y = None
+
+        assert self.model is not None
+
+        acqf = get_acquisition_function(
+            self.acquisition_function.__class__.__name__,
+            self.model,
+            ref_point=self.get_adjusted_refpoint(),
+            objective=objective,
+            X_observed=X_train,
+            X_pending=X_pending,
+            constraints=constraints,
+            eta=etas,
+            mc_samples=self.num_sobol_samples,
+            cache_root=True if isinstance(self.model, GPyTorchModel) else False,
+            alpha=self.acquisition_function.alpha,
+            prune_baseline=self.acquisition_function.prune_baseline
+            if isinstance(self.acquisition_function, (qLogNEHVI, qNEHVI))
+            else True,
+            Y=Y,
+        )
+        return [acqf]
+
+    # def _get_acqfs(
+    #     self, n
+    # ) -> List[
+    #     Union[
+    #         qExpectedHypervolumeImprovement,
+    #         qNoisyExpectedHypervolumeImprovement,
+    #         qLogNoisyExpectedHypervolumeImprovement,
+    #         qLogExpectedHypervolumeImprovement,
+    #     ]
+    # ]:
+    #     df = self.domain.outputs.preprocess_experiments_all_valid_outputs(
+    #         self.experiments
+    #     )
+
+    #     train_obj = (
+    #         df[self.domain.outputs.get_keys_by_objective(excludes=None)].values
+    #         * self.ref_point_mask
+    #     )
+    #     ref_point = self.get_adjusted_refpoint()
+    #     weights = np.array(
+    #         [
+    #             feat.objective.w  # type: ignore
+    #             for feat in self.domain.outputs.get_by_objective(excludes=None)
+    #         ]
+    #     )
+    #     # compute points that are better than the known reference point
+    #     better_than_ref = (train_obj > ref_point).all(axis=-1)
+    #     # partition non-dominated space into disjoint rectangles
+    #     partitioning = NondominatedPartitioning(
+    #         ref_point=torch.from_numpy(ref_point * weights),
+    #         # use observations that are better than the specified reference point and feasible
+    #         Y=torch.from_numpy(train_obj[better_than_ref]),
+    #     )
+
+    #     _, X_pending = self.get_acqf_input_tensors()
+
+    #     assert self.model is not None
+    #     # setup the acqf
+    #     acqf = qExpectedHypervolumeImprovement(
+    #         model=self.model,
+    #         ref_point=ref_point,  # use known reference point
+    #         partitioning=partitioning,
+    #         # sampler=self.sampler,
+    #         # define an objective that specifies which outcomes are the objectives
+    #         objective=self._get_objective(),
+    #         X_pending=X_pending,
+    #     )
+    #     acqf._default_sample_shape = torch.Size([self.num_sobol_samples])
+    #     return [acqf]
+
+    def _get_objective(self) -> GenericMCMultiOutputObjective:
+        objective = get_multiobjective_objective(outputs=self.domain.outputs)
+        return GenericMCMultiOutputObjective(objective=objective)
+
+    def get_adjusted_refpoint(self) -> List[float]:
+        if self.ref_point is None:
+            df = self.domain.outputs.preprocess_experiments_all_valid_outputs(
+                self.experiments
+            )
+            ref_point = infer_ref_point(
+                self.domain, experiments=df, return_masked=False
+            )
+        else:
+            ref_point = self.ref_point
+        return (
+            self.ref_point_mask
+            * np.array(
+                [
+                    ref_point[feat]
+                    for feat in self.domain.outputs.get_keys_by_objective(
+                        excludes=ConstrainedObjective
+                    )
+                ]
+            )
+        ).tolist()
diff --git a/bofire/strategies/predictives/sobo.py b/bofire/strategies/predictives/sobo.py
index 686219c49..5a05b33c3 100644
--- a/bofire/strategies/predictives/sobo.py
+++ b/bofire/strategies/predictives/sobo.py
@@ -12,13 +12,10 @@
 import torch
 from botorch.acquisition import get_acquisition_function
 from botorch.acquisition.acquisition import AcquisitionFunction
-from botorch.acquisition.objective import (
-    ConstrainedMCObjective,
-    GenericMCObjective,
-)
+from botorch.acquisition.objective import ConstrainedMCObjective, GenericMCObjective
 from botorch.models.gpytorch import GPyTorchModel
 
-from bofire.data_models.acquisition_functions.api import qPI, qSR, qUCB
+from bofire.data_models.acquisition_functions.api import qLogNEI, qNEI, qPI, qSR, qUCB
 from bofire.data_models.objectives.api import ConstrainedObjective, Objective
 from bofire.data_models.strategies.api import AdditiveSoboStrategy as AdditiveDataModel
 from bofire.data_models.strategies.api import CustomSoboStrategy as CustomDataModel
@@ -57,9 +54,11 @@ def _get_acqfs(self, n) -> List[AcquisitionFunction]:
             etas,
         ) = self._get_objective_and_constraints()
 
+        assert self.model is not None
+
         acqf = get_acquisition_function(
             self.acquisition_function.__class__.__name__,
-            self.model,  # type: ignore
+            self.model,
             objective_callable,
             X_observed=X_train,
             X_pending=X_pending,
@@ -73,6 +72,9 @@ def _get_acqfs(self, n) -> List[AcquisitionFunction]:
             else 1e-3,
             eta=torch.tensor(etas).to(**tkwargs),
             cache_root=True if isinstance(self.model, GPyTorchModel) else False,
+            prune_baseline=self.acquisition_function.prune_baseline
+            if isinstance(self.acquisition_function, (qNEI, qLogNEI))
+            else True,
         )
         return [acqf]
 
diff --git a/setup.py b/setup.py
index 14eaf6938..58d23cf94 100644
--- a/setup.py
+++ b/setup.py
@@ -42,7 +42,7 @@
     ],
     extras_require={
         "optimization": [
-            "botorch>=0.9.2",
+            "botorch>=0.9.4",
             "multiprocess",
             "plotly",
             "formulaic>=0.6.0",
diff --git a/tests/bofire/data_models/specs/acquisition_functions.py b/tests/bofire/data_models/specs/acquisition_functions.py
index bcf99ddac..3ea7ed7ce 100644
--- a/tests/bofire/data_models/specs/acquisition_functions.py
+++ b/tests/bofire/data_models/specs/acquisition_functions.py
@@ -17,12 +17,12 @@
 
 specs.add_valid(
     acquisition_functions.qNEI,
-    lambda: {},
+    lambda: {"prune_baseline": random.choice([True, False])},
 )
 
 specs.add_valid(
     acquisition_functions.qLogNEI,
-    lambda: {},
+    lambda: {"prune_baseline": random.choice([True, False])},
 )
 
 
@@ -44,3 +44,27 @@
         "beta": random.random(),
     },
 )
+
+specs.add_valid(
+    acquisition_functions.qEHVI,
+    lambda: {
+        "alpha": random.random(),
+    },
+)
+
+specs.add_valid(
+    acquisition_functions.qLogEHVI,
+    lambda: {
+        "alpha": random.random(),
+    },
+)
+
+specs.add_valid(
+    acquisition_functions.qNEHVI,
+    lambda: {"alpha": random.random(), "prune_baseline": random.choice([True, False])},
+)
+
+specs.add_valid(
+    acquisition_functions.qLogNEHVI,
+    lambda: {"alpha": random.random(), "prune_baseline": random.choice([True, False])},
+)
diff --git a/tests/bofire/data_models/specs/specs.py b/tests/bofire/data_models/specs/specs.py
index 108d661a5..a93875a70 100644
--- a/tests/bofire/data_models/specs/specs.py
+++ b/tests/bofire/data_models/specs/specs.py
@@ -71,32 +71,35 @@ def __init__(self, invalidators: List[Invalidator]):
         self.valids: List[Spec] = []
         self.invalids: List[Spec] = []
 
-    def _get_spec(self, specs: List[Spec], cls: Type = None):
+    def _get_spec(self, specs: List[Spec], cls: Type = None, exact: bool = True):
         if cls is not None:
-            specs = [s for s in specs if s.cls == cls]
+            if exact:
+                specs = [s for s in specs if s.cls == cls]
+            else:
+                specs = [s for s in specs if issubclass(s.cls, cls)]
         if len(specs) == 0 and cls is None:
             raise TypeError("no spec found")
         elif len(specs) == 0:
             raise TypeError(f"no spec of type {cls.__name__} found")
         return random.choice(specs)
 
-    def valid(self, cls: Type = None) -> Spec:
+    def valid(self, cls: Type = None, exact: bool = True) -> Spec:
         """Return a valid spec.
 
         If <cls> is provided, the list of all valid specs is filtered by it.
         If no spec (with the specified class) exists, a TypeError is raised.
         If more than one spec exist, a random one is returned."""
 
-        return self._get_spec(self.valids, cls)
+        return self._get_spec(self.valids, cls, exact)
 
-    def invalid(self, cls: Type = None) -> Spec:
+    def invalid(self, cls: Type = None, exact: bool = True) -> Spec:
         """Return an invalid spec.
 
         If <cls> is provided, the list of all invalid specs is filtered by it.
         If no spec (with the specified class) exists, a TypeError is raised.
         If more than one spec exist, a random one is returned."""
 
-        return self._get_spec(self.invalids, cls)
+        return self._get_spec(self.invalids, cls, exact)
 
     def add_valid(
         self, cls: Type, spec: Callable[[], dict], add_invalids: bool = True
diff --git a/tests/bofire/data_models/specs/strategies.py b/tests/bofire/data_models/specs/strategies.py
index 5299ae1b3..a34b4925e 100644
--- a/tests/bofire/data_models/specs/strategies.py
+++ b/tests/bofire/data_models/specs/strategies.py
@@ -1,6 +1,6 @@
 import bofire.data_models.strategies.api as strategies
 from bofire.benchmarks.single import Himmelblau
-from bofire.data_models.acquisition_functions.api import qEI, qPI
+from bofire.data_models.acquisition_functions.api import qEI, qLogNEHVI, qPI
 from bofire.data_models.domain.api import Domain, Inputs
 from bofire.data_models.enum import CategoricalMethodEnum, SamplingMethodEnum
 from bofire.data_models.features.api import (
@@ -54,6 +54,14 @@
         **strategy_commons,
     },
 )
+specs.add_valid(
+    strategies.MoboStrategy,
+    lambda: {
+        "domain": domain.valid().obj().dict(),
+        "acquisition_function": qLogNEHVI().dict(),
+        **strategy_commons,
+    },
+)
 specs.add_valid(
     strategies.SoboStrategy,
     lambda: {
diff --git a/tests/bofire/strategies/test_mobo.py b/tests/bofire/strategies/test_mobo.py
new file mode 100644
index 000000000..3d6371b60
--- /dev/null
+++ b/tests/bofire/strategies/test_mobo.py
@@ -0,0 +1,213 @@
+from itertools import chain
+
+import numpy as np
+import pytest
+import torch
+from botorch.acquisition.multi_objective import (  # qLogExpectedHypervolumeImprovement,; qLogNoisyExpectedHypervolumeImprovement,
+    qExpectedHypervolumeImprovement,
+    qNoisyExpectedHypervolumeImprovement,
+)
+from botorch.acquisition.multi_objective.logei import (  # qExpectedHypervolumeImprovement,
+    qLogExpectedHypervolumeImprovement,
+    qLogNoisyExpectedHypervolumeImprovement,
+)
+
+# qNoisyExpectedHypervolumeImprovement,
+from botorch.acquisition.multi_objective.objective import GenericMCMultiOutputObjective
+
+import bofire.data_models.acquisition_functions.api as acquisitions
+import bofire.data_models.strategies.api as data_models
+import bofire.strategies.api as strategies
+from bofire.benchmarks.multi import C2DTLZ2, DTLZ2
+from bofire.data_models.features.api import ContinuousOutput
+from bofire.data_models.strategies.api import (
+    PolytopeSampler as PolytopeSamplerDataModel,
+)
+from bofire.strategies.api import PolytopeSampler
+from tests.bofire.utils.test_multiobjective import (
+    dfs,
+    invalid_domains,
+    valid_constrained_domains,
+    valid_domains,
+)
+
+
+@pytest.mark.parametrize(
+    "domain, ref_point",
+    [
+        (invalid_domains[0], None),
+        (invalid_domains[1], None),
+        (valid_domains[0], [0]),
+        (valid_domains[0], {}),
+        (valid_domains[0], {"of1": 0.0, "of2": 0, "of3": 0}),
+        (valid_domains[0], {"of1": 0.0}),
+        (valid_domains[0], {"of1": 0.0, "of3": 0.0}),
+    ],
+)
+def test_invalid_mobo(domain, ref_point):
+    with pytest.raises(ValueError):
+        data_models.MoboStrategy(domain=domain, ref_point=ref_point)
+
+
+@pytest.mark.parametrize("domain", valid_constrained_domains)
+def test_qnehvi_valid_constrained_objectives(domain):
+    data_models.MoboStrategy(domain=domain)
+
+
+@pytest.mark.parametrize(
+    "domain, ref_point, experiments, expected",
+    [
+        (valid_domains[0], {"of1": 0.5, "of2": 10.0}, dfs[0], [0.5, -10.0]),
+        (valid_domains[1], {"of1": 0.5, "of3": 0.5}, dfs[1], [0.5, 0.5]),
+        (valid_domains[0], None, dfs[0], [1.0, -5.0]),
+        (valid_domains[1], None, dfs[1], [1.0, 2.0]),
+    ],
+)
+def test_mobo_get_adjusted_refpoint(domain, ref_point, experiments, expected):
+    data_model = data_models.MoboStrategy(domain=domain, ref_point=ref_point)
+    strategy = strategies.map(data_model)
+    # hack for the test to prevent training of the model when using tell
+    strategy.set_experiments(experiments)
+    adjusted_ref_point = strategy.get_adjusted_refpoint()
+    assert isinstance(adjusted_ref_point, list)
+    assert np.allclose(expected, np.asarray(adjusted_ref_point))
+
+
+@pytest.mark.parametrize(
+    "strategy, use_ref_point, acqf",
+    [
+        (data_models.MoboStrategy, use_ref_point, acqf)
+        for use_ref_point in [True, False]
+        for acqf in [
+            acquisitions.qEHVI,
+            acquisitions.qLogEHVI,
+            acquisitions.qNEHVI,
+            acquisitions.qLogNEHVI,
+        ]
+    ],
+)
+def test_mobo(strategy, use_ref_point, acqf):
+    # generate data
+    benchmark = DTLZ2(dim=6)
+    random_strategy = PolytopeSampler(
+        data_model=PolytopeSamplerDataModel(domain=benchmark.domain)
+    )
+    experiments = benchmark.f(random_strategy._ask(n=10), return_complete=True)
+    # init strategy
+    data_model = strategy(
+        domain=benchmark.domain,
+        ref_point=benchmark.ref_point if use_ref_point else None,
+        acquisition_function=acqf(),
+    )
+    my_strategy = strategies.map(data_model)
+    my_strategy.tell(experiments)
+
+    bacqf = my_strategy._get_acqfs(2)[0]
+
+    assert isinstance(bacqf.objective, GenericMCMultiOutputObjective)
+    if isinstance(acqf, acquisitions.qEHVI):
+        assert isinstance(bacqf, qExpectedHypervolumeImprovement)
+    elif isinstance(acqf, acquisitions.qNEHVI):
+        assert isinstance(bacqf, qNoisyExpectedHypervolumeImprovement)
+    elif isinstance(acqf, acquisitions.qLogNEHVI):
+        assert isinstance(bacqf, qLogNoisyExpectedHypervolumeImprovement)
+    elif isinstance(acqf, acquisitions.qLogEHVI):
+        assert isinstance(bacqf, qLogExpectedHypervolumeImprovement)
+
+
+@pytest.mark.parametrize(
+    "acqf",
+    [
+        acquisitions.qEHVI,
+        acquisitions.qLogEHVI,
+        acquisitions.qNEHVI,
+        acquisitions.qLogNEHVI,
+    ],
+)
+def test_mobo_constraints(acqf):
+    benchmark = C2DTLZ2(dim=4)
+    random_strategy = PolytopeSampler(
+        data_model=PolytopeSamplerDataModel(domain=benchmark.domain)
+    )
+    experiments = benchmark.f(random_strategy._ask(n=10), return_complete=True)
+    data_model = data_models.MoboStrategy(
+        domain=benchmark.domain,
+        ref_point={"f_0": 1.1, "f_1": 1.1},
+        acquisition_function=acqf(),
+    )
+    my_strategy = strategies.map(data_model)
+    my_strategy.tell(experiments)
+    bacqf = my_strategy._get_acqfs(2)[0]
+    assert isinstance(bacqf.objective, GenericMCMultiOutputObjective)
+    if isinstance(acqf, acquisitions.qEHVI):
+        assert isinstance(bacqf, qExpectedHypervolumeImprovement)
+    elif isinstance(acqf, acquisitions.qNEHVI):
+        assert isinstance(bacqf, qNoisyExpectedHypervolumeImprovement)
+    elif isinstance(acqf, acquisitions.qLogNEHVI):
+        assert isinstance(bacqf, qLogNoisyExpectedHypervolumeImprovement)
+    elif isinstance(acqf, acquisitions.qLogEHVI):
+        assert isinstance(bacqf, qLogExpectedHypervolumeImprovement)
+    assert bacqf.eta == torch.tensor(1e-3)
+    assert len(bacqf.constraints) == 1
+    assert torch.allclose(
+        bacqf.ref_point,
+        torch.tensor([-1.1, -1.1], dtype=torch.double),
+    )
+
+
+@pytest.mark.parametrize(
+    "num_experiments, num_candidates",
+    [
+        (num_experiments, num_candidates)
+        for num_experiments in range(8, 10)
+        for num_candidates in range(1, 3)
+    ],
+)
+@pytest.mark.slow
+def test_get_acqf_input(num_experiments, num_candidates):
+    # generate data
+    benchmark = DTLZ2(dim=6)
+    random_strategy = PolytopeSampler(
+        data_model=PolytopeSamplerDataModel(domain=benchmark.domain)
+    )
+    experiments = benchmark.f(
+        random_strategy._ask(n=num_experiments), return_complete=True
+    )
+    data_model = data_models.MoboStrategy(domain=benchmark.domain)
+    strategy = strategies.map(data_model)
+    # , ref_point=ref_pointw
+
+    strategy.tell(experiments)
+    strategy.ask(candidate_count=num_candidates, add_pending=True)
+
+    X_train, X_pending = strategy.get_acqf_input_tensors()
+
+    _, names = strategy.domain.inputs._get_transform_info(
+        specs=strategy.surrogate_specs.input_preprocessing_specs
+    )
+
+    assert torch.is_tensor(X_train)
+    assert torch.is_tensor(X_pending)
+    assert X_train.shape == (
+        num_experiments,
+        len(set(chain(*names.values()))),
+    )
+    assert X_pending.shape == (
+        num_candidates,
+        len(set(chain(*names.values()))),
+    )
+
+
+def test_no_objective():
+    domain = DTLZ2(dim=6).domain
+    experiments = DTLZ2(dim=6).f(domain.inputs.sample(10), return_complete=True)
+    domain.outputs.features.append(ContinuousOutput(key="ignore", objective=None))
+    experiments["ignore"] = experiments["f_0"] + 6
+    experiments["valid_ignore"] = 1
+    data_model = data_models.MoboStrategy(
+        domain=domain, ref_point={"f_0": 1.1, "f_1": 1.1}
+    )
+    recommender = strategies.map(data_model=data_model)
+    recommender.tell(experiments=experiments)
+    candidates = recommender.ask(candidate_count=1)
+    recommender.to_candidates(candidates)
diff --git a/tests/bofire/strategies/test_sobo.py b/tests/bofire/strategies/test_sobo.py
index 6f4cdc506..700a376b2 100644
--- a/tests/bofire/strategies/test_sobo.py
+++ b/tests/bofire/strategies/test_sobo.py
@@ -19,6 +19,7 @@
 from bofire.benchmarks.multi import DTLZ2
 from bofire.benchmarks.single import Himmelblau, _CategoricalDiscreteHimmelblau
 from bofire.data_models.acquisition_functions.api import (
+    SingleObjectiveAcquisitionFunction,
     qEI,
     qLogEI,
     qLogNEI,
@@ -43,7 +44,9 @@
 
 VALID_BOTORCH_SOBO_STRATEGY_SPEC = {
     "domain": domains[1],
-    "acquisition_function": specs.acquisition_functions.valid().obj(),
+    "acquisition_function": specs.acquisition_functions.valid(
+        SingleObjectiveAcquisitionFunction, exact=False
+    ).obj(),
     # "num_sobol_samples": 1024,
     # "num_restarts": 8,
     # "num_raw_samples": 1024,
@@ -67,7 +70,9 @@
 
 VALID_ADDITIVE_AND_MULTIPLICATIVE_BOTORCH_SOBO_STRATEGY_SPEC = {
     "domain": domains[2],
-    "acquisition_function": specs.acquisition_functions.valid().obj(),
+    "acquisition_function": specs.acquisition_functions.valid(
+        SingleObjectiveAcquisitionFunction, exact=False
+    ).obj(),
     "descriptor_method": "EXHAUSTIVE",
     "categorical_method": "EXHAUSTIVE",
 }
diff --git a/tutorials/benchmarks/002-DTLZ2.ipynb b/tutorials/benchmarks/002-DTLZ2.ipynb
index 88cf681fd..3dab74632 100644
--- a/tutorials/benchmarks/002-DTLZ2.ipynb
+++ b/tutorials/benchmarks/002-DTLZ2.ipynb
@@ -10,23 +10,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 8,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/opt/homebrew/Caskroom/miniforge/base/envs/bofire/lib/python3.10/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
-      "  from .autonotebook import tqdm as notebook_tqdm\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from bofire.benchmarks.multi import DTLZ2\n",
     "from bofire.runners.api import run\n",
     "from bofire.utils.multiobjective import compute_hypervolume\n",
-    "from bofire.data_models.strategies.api import QehviStrategy, QparegoStrategy, RandomStrategy, PolytopeSampler\n",
+    "from bofire.data_models.strategies.api import QehviStrategy, QparegoStrategy, RandomStrategy, PolytopeSampler, MoboStrategy\n",
     "import bofire.strategies.api as strategies\n",
     "from bofire.data_models.api import Domain, Outputs, Inputs\n",
     "from bofire.data_models.features.api import ContinuousInput, ContinuousOutput\n",
@@ -50,7 +41,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -71,14 +62,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "run 00 with current best 0.118: 100%|██████████| 50/50 [00:00<00:00, 98.77it/s]\n"
+      "run 00 with current best 0.157: 100%|██████████| 50/50 [00:00<00:00, 73.96it/s]\n"
      ]
     }
    ],
@@ -110,26 +101,26 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## QEHVI Strategy\n",
+    "## MOBO Strategy\n",
     "### Automatic run"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "run 00 with current best 0.306:  34%|█████████████████                                 | 17/50 [03:21<05:55, 10.77s/it]"
+      "run 00 with current best 0.387: 100%|██████████| 50/50 [03:31<00:00,  4.22s/it]\n"
      ]
     }
    ],
    "source": [
     "def strategy_factory(domain: Domain):\n",
-    "    data_model = QehviStrategy(domain=domain,  ref_point={\"f_0\": 1.1, \"f_1\": 1.1})\n",
+    "    data_model = MoboStrategy(domain=domain,  ref_point={\"f_0\": 1.1, \"f_1\": 1.1})\n",
     "    return strategies.map(data_model)\n",
     "\n",
     "results = run(\n",
@@ -155,9 +146,75 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>x_0</th>\n",
+       "      <th>x_1</th>\n",
+       "      <th>x_2</th>\n",
+       "      <th>x_3</th>\n",
+       "      <th>x_4</th>\n",
+       "      <th>x_5</th>\n",
+       "      <th>f_0_pred</th>\n",
+       "      <th>f_1_pred</th>\n",
+       "      <th>f_0_sd</th>\n",
+       "      <th>f_1_sd</th>\n",
+       "      <th>f_0_des</th>\n",
+       "      <th>f_1_des</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0.613312</td>\n",
+       "      <td>0.320123</td>\n",
+       "      <td>0.944065</td>\n",
+       "      <td>0.115862</td>\n",
+       "      <td>0.774695</td>\n",
+       "      <td>0.502501</td>\n",
+       "      <td>0.82386</td>\n",
+       "      <td>0.920911</td>\n",
+       "      <td>0.457239</td>\n",
+       "      <td>0.364747</td>\n",
+       "      <td>-0.82386</td>\n",
+       "      <td>-0.920911</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "        x_0       x_1       x_2  ...    f_1_sd  f_0_des   f_1_des\n",
+       "0  0.613312  0.320123  0.944065  ...  0.364747 -0.82386 -0.920911\n",
+       "\n",
+       "[1 rows x 12 columns]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# we get the domain from the benchmark module, in real use case we have to build it on our own\n",
     "# make sure that the objective is set correctly\n",
@@ -167,7 +224,7 @@
     "# we setup the strategy\n",
     "# providing of a reference point is not mandatory but can help\n",
     "# the reference point has to be wrt to the assigned objective always worse than the points on the paretofront.\n",
-    "data_model = QehviStrategy(domain=domain, ref_point={\"f_0\": 1.1, \"f_1\": 1.1})\n",
+    "data_model = MoboStrategy(domain=domain, ref_point={\"f_0\": 1.1, \"f_1\": 1.1})\n",
     "recommender = strategies.map(data_model=data_model)\n",
     "# we tell the strategy our historical data\n",
     "recommender.tell(experiments=experiments)\n",
@@ -189,7 +246,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
@@ -230,29 +287,28 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>0</th>\n",
-       "      <td>0.962721</td>\n",
-       "      <td>0.590134</td>\n",
-       "      <td>0.6355</td>\n",
-       "      <td>0.064779</td>\n",
+       "      <td>0.970739</td>\n",
+       "      <td>0.0</td>\n",
        "      <td>1.0</td>\n",
-       "      <td>0.207502</td>\n",
-       "      <td>0.25204</td>\n",
-       "      <td>0.958283</td>\n",
-       "      <td>0.145824</td>\n",
-       "      <td>0.000918</td>\n",
-       "      <td>-0.25204</td>\n",
-       "      <td>-0.958283</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.134032</td>\n",
+       "      <td>0.954235</td>\n",
+       "      <td>0.159501</td>\n",
+       "      <td>0.357115</td>\n",
+       "      <td>-0.134032</td>\n",
+       "      <td>-0.954235</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
        "</div>"
       ],
       "text/plain": [
-       "        x_0       x_1     x_2       x_3  x_4       x_5  f_0_pred  f_1_pred  \\\n",
-       "0  0.962721  0.590134  0.6355  0.064779  1.0  0.207502   0.25204  0.958283   \n",
+       "        x_0  x_1  x_2  x_3  ...    f_0_sd    f_1_sd   f_0_des   f_1_des\n",
+       "0  0.970739  0.0  1.0  0.0  ...  0.159501  0.357115 -0.134032 -0.954235\n",
        "\n",
-       "     f_0_sd    f_1_sd  f_0_des   f_1_des  \n",
-       "0  0.145824  0.000918 -0.25204 -0.958283  "
+       "[1 rows x 12 columns]"
       ]
      },
      "metadata": {},
@@ -265,7 +321,7 @@
     "\n",
     "# in this case you would use non default kernels for the different outputs\n",
     "# it is also possible to build the models for a subset of the complete features\n",
-    "data_model = QehviStrategy(domain=domain, ref_point={\"f_0\": 1.1, \"f_1\": 1.1}, \n",
+    "data_model = MoboStrategy(domain=domain, ref_point={\"f_0\": 1.1, \"f_1\": 1.1}, \n",
     "    surrogate_specs=BotorchSurrogates(surrogates=[\n",
     "        SingleTaskGPSurrogate(\n",
     "            inputs=domain.inputs,\n",
@@ -295,9 +351,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 14,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "run 00 with current best 0.335: 100%|██████████| 50/50 [00:57<00:00,  1.16s/it]\n"
+     ]
+    }
+   ],
    "source": [
     "results_qparego = run(\n",
     "    DTLZ2(dim=6),\n",
@@ -335,7 +399,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -358,6 +422,13 @@
     "ax.set_xlabel(\"f_0\")\n",
     "ax.set_ylabel(\"f_1\")"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {