diff --git a/flexmeasures/data/models/planning/__init__.py b/flexmeasures/data/models/planning/__init__.py
index f93599d095..4caf906a60 100644
--- a/flexmeasures/data/models/planning/__init__.py
+++ b/flexmeasures/data/models/planning/__init__.py
@@ -288,12 +288,25 @@ class Commitment:
     quantity: pd.Series = 0
     upwards_deviation_price: pd.Series = 0
     downwards_deviation_price: pd.Series = 0
+    commodity: str | pd.Series | None = None
 
     def __post_init__(self):
+        if (
+            isinstance(self, FlowCommitment)
+            and isinstance(self.commodity, pd.Series)
+            and self.device is not None
+        ):
+            devices = extract_devices(self.device)
+            missing = set(devices) - set(self.commodity.index)
+            if missing:
+                raise ValueError(f"commodity mapping missing for devices: {missing}")
+
         series_attributes = [
             attr
             for attr, _type in self.__annotations__.items()
-            if _type == "pd.Series" and hasattr(self, attr)
+            if _type == "pd.Series"
+            and hasattr(self, attr)
+            and attr not in ("device_group", "commodity")
         ]
         for series_attr in series_attributes:
             val = getattr(self, series_attr)
@@ -386,6 +399,10 @@ def _init_device_group(self):
                 range(len(devices)), index=devices, name="device_group"
             )
         else:
+            if not isinstance(self.device_group, pd.Series):
+                self.device_group = pd.Series(
+                    self.device_group, index=devices, name="device_group"
+                )
             # Validate custom grouping
             missing = set(devices) - set(self.device_group.index)
             if missing:
@@ -435,12 +452,25 @@ def to_frame(self) -> pd.DataFrame:
             ],
             axis=1,
         )
-        # map device → device_group
+        # device_group
         if self.device is not None:
             df["device_group"] = map_device_to_group(self.device, self.device_group)
         else:
             df["device_group"] = 0
 
+        # commodity
+        if getattr(self, "commodity", None) is None:
+            df["commodity"] = None
+        elif isinstance(self.commodity, pd.Series):
+            # commodity is a device→commodity mapping, like device_group
+            if self.device is None:
+                df["commodity"] = None
+            else:
+                df["commodity"] = map_device_to_group(self.device, self.commodity)
+        else:
+            # scalar commodity
+            df["commodity"] = self.commodity
+
         return df
 
 
diff --git a/flexmeasures/data/models/planning/linear_optimization.py b/flexmeasures/data/models/planning/linear_optimization.py
index 37bada383b..4141042509 100644
--- a/flexmeasures/data/models/planning/linear_optimization.py
+++ b/flexmeasures/data/models/planning/linear_optimization.py
@@ -135,6 +135,20 @@ def device_scheduler(  # noqa C901
             df["group"] = group
             commitments.append(df)
 
+    # commodity → set(device indices)
+    commodity_devices = {}
+
+    for df in commitments:
+        if "commodity" not in df.columns or "device" not in df.columns:
+            continue
+
+        for _, row in df[["commodity", "device"]].dropna().iterrows():
+            devices = row["device"]
+            if not isinstance(devices, (list, tuple, set)):
+                devices = [devices]
+
+            commodity_devices.setdefault(row["commodity"], set()).update(devices)
+
     # Check if commitments have the same time window and resolution as the constraints
     for commitment in commitments:
         start_c = commitment.index.to_pydatetime()[0]
@@ -579,45 +593,30 @@ def device_stock_commitment_equalities(m, c, j, d):
         )
 
     def ems_flow_commitment_equalities(m, c, j):
-        """Couple EMS flows (sum over devices) to each commitment.
+        """Couple EMS flow commitments to device flows, optionally filtered by commodity."""
 
-        - Creates an inequality for one-sided commitments.
-        - Creates an equality for two-sided commitments and for groups of size 1.
-        """
-        if (
-            "device" in commitments[c].columns
-            and not pd.isnull(commitments[c]["device"]).all()
-        ) or m.commitment_quantity[c, j] == -infinity:
-            # Commitment c does not concern EMS
+        if commitments[c]["class"].iloc[0] != FlowCommitment:
             return Constraint.Skip
-        if (
-            "class" in commitments[c].columns
-            and not (
-                commitments[c]["class"].apply(lambda cl: cl == FlowCommitment)
-            ).all()
-        ):
-            raise NotImplementedError(
-                "StockCommitment on an EMS level has not been implemented. Please file a GitHub ticket explaining your use case."
-            )
+
+        # Legacy behavior: no commodity → sum over all devices
+        if "commodity" not in commitments[c].columns:
+            devices = m.d
+        else:
+            commodity = commitments[c]["commodity"].iloc[0]
+            if pd.isna(commodity):
+                devices = m.d
+            else:
+                devices = commodity_devices.get(commodity, set())
+                if not devices:
+                    return Constraint.Skip
+
         return (
-            (
-                0
-                if len(commitments[c]) == 1
-                or "upwards deviation price" in commitments[c].columns
-                else None
-            ),
-            # 0 if "upwards deviation price" in commitments[c].columns else None,  # todo: possible simplification
+            None,
             m.commitment_quantity[c, j]
             + m.commitment_downwards_deviation[c]
             + m.commitment_upwards_deviation[c]
-            - sum(m.ems_power[:, j]),
-            (
-                0
-                if len(commitments[c]) == 1
-                or "downwards deviation price" in commitments[c].columns
-                else None
-            ),
-            # 0 if "downwards deviation price" in commitments[c].columns else None,  # todo: possible simplification
+            - sum(m.ems_power[d, j] for d in devices),
+            None,
         )
 
     def device_derivative_equalities(m, d, j):
@@ -718,6 +717,22 @@ def cost_function(m):
         )
 
     model.commitment_costs = commitment_costs
+    commodity_costs = {}
+    for c in model.c:
+        commodity = None
+        if "commodity" in commitments[c].columns:
+            commodity = commitments[c]["commodity"].iloc[0]
+        if commodity is None or (isinstance(commodity, float) and np.isnan(commodity)):
+            continue
+
+        cost = value(
+            model.commitment_downwards_deviation[c] * model.down_price[c]
+            + model.commitment_upwards_deviation[c] * model.up_price[c]
+        )
+        commodity_costs[commodity] = commodity_costs.get(commodity, 0) + cost
+
+    model.commodity_costs = commodity_costs
+
     # model.pprint()
     # model.display()
     # print(results.solver.termination_condition)
diff --git a/flexmeasures/data/models/planning/storage.py b/flexmeasures/data/models/planning/storage.py
index 4d17ee4596..0101b84d0f 100644
--- a/flexmeasures/data/models/planning/storage.py
+++ b/flexmeasures/data/models/planning/storage.py
@@ -159,12 +159,15 @@ def _prepare(self, skip_validation: bool = False) -> tuple:  # noqa: C901
         # Get info from flex-context
         consumption_price_sensor = self.flex_context.get("consumption_price_sensor")
         production_price_sensor = self.flex_context.get("production_price_sensor")
+        gas_price_sensor = self.flex_context.get("gas_price_sensor")
+
         consumption_price = self.flex_context.get(
             "consumption_price", consumption_price_sensor
         )
         production_price = self.flex_context.get(
             "production_price", production_price_sensor
         )
+        gas_price = self.flex_context.get("gas_price", gas_price_sensor)
         # fallback to using the consumption price, for backwards compatibility
         if production_price is None:
             production_price = consumption_price
@@ -175,6 +178,23 @@ def _prepare(self, skip_validation: bool = False) -> tuple:  # noqa: C901
         # Fetch the device's power capacity (required Sensor attribute)
         power_capacity_in_mw = self._get_device_power_capacity(flex_model, assets)
 
+        gas_deviation_prices = None
+        if gas_price is not None:
+            gas_deviation_prices = get_continuous_series_sensor_or_quantity(
+                variable_quantity=gas_price,
+                unit=self.flex_context["shared_currency_unit"] + "/MWh",
+                query_window=(start, end),
+                resolution=resolution,
+                beliefs_before=belief_time,
+                fill_sides=True,
+            ).to_frame(name="event_value")
+            ensure_prices_are_not_empty(gas_deviation_prices, gas_price)
+            gas_deviation_prices = (
+                gas_deviation_prices.loc[start : end - resolution]["event_value"]
+                * resolution
+                / pd.Timedelta("1h")
+            )
+
         # Check for known prices or price forecasts
         up_deviation_prices = get_continuous_series_sensor_or_quantity(
             variable_quantity=consumption_price,
@@ -239,7 +259,10 @@ def _prepare(self, skip_validation: bool = False) -> tuple:  # noqa: C901
 
         # Set up commitments to optimise for
         commitments = self.convert_to_commitments(
-            query_window=(start, end), resolution=resolution, beliefs_before=belief_time
+            query_window=(start, end),
+            resolution=resolution,
+            beliefs_before=belief_time,
+            flex_model=flex_model,
         )
 
         index = initialize_index(start, end, resolution)
@@ -258,188 +281,233 @@ def _prepare(self, skip_validation: bool = False) -> tuple:  # noqa: C901
         )
 
         # Set up commitments DataFrame
-        commitment = FlowCommitment(
-            name="energy",
-            quantity=commitment_quantities,
-            upwards_deviation_price=commitment_upwards_deviation_price,
-            downwards_deviation_price=commitment_downwards_deviation_price,
-            index=index,
-        )
-        commitments.append(commitment)
-
-        # Set up peak commitments
-        if self.flex_context.get("ems_peak_consumption_price") is not None:
-            ems_peak_consumption = get_continuous_series_sensor_or_quantity(
-                variable_quantity=self.flex_context.get("ems_peak_consumption_in_mw"),
-                unit="MW",
-                query_window=(start, end),
-                resolution=resolution,
-                beliefs_before=belief_time,
-                max_value=np.inf,  # np.nan -> np.inf to ignore commitment if no quantity is given
-                fill_sides=True,
-            )
-            ems_peak_consumption_price = self.flex_context.get(
-                "ems_peak_consumption_price"
-            )
-            ems_peak_consumption_price = get_continuous_series_sensor_or_quantity(
-                variable_quantity=ems_peak_consumption_price,
-                unit=self.flex_context["shared_currency_unit"] + "/MW",
-                query_window=(start, end),
-                resolution=resolution,
-                beliefs_before=belief_time,
-                fill_sides=True,
-            )
-
-            # Set up commitments DataFrame
-            commitment = FlowCommitment(
-                name="consumption peak",
-                quantity=ems_peak_consumption,
-                # positive price because breaching in the upwards (consumption) direction is penalized
-                upwards_deviation_price=ems_peak_consumption_price,
-                _type="any",
-                index=index,
-            )
-            commitments.append(commitment)
-        if self.flex_context.get("ems_peak_production_price") is not None:
-            ems_peak_production = get_continuous_series_sensor_or_quantity(
-                variable_quantity=self.flex_context.get("ems_peak_production_in_mw"),
-                unit="MW",
-                query_window=(start, end),
-                resolution=resolution,
-                beliefs_before=belief_time,
-                max_value=np.inf,  # np.nan -> np.inf to ignore commitment if no quantity is given
-                fill_sides=True,
-            )
-            ems_peak_production_price = self.flex_context.get(
-                "ems_peak_production_price"
-            )
-            ems_peak_production_price = get_continuous_series_sensor_or_quantity(
-                variable_quantity=ems_peak_production_price,
-                unit=self.flex_context["shared_currency_unit"] + "/MW",
-                query_window=(start, end),
-                resolution=resolution,
-                beliefs_before=belief_time,
-                fill_sides=True,
-            )
+        for d, flex_model_d in enumerate(flex_model):
+            commodity = flex_model_d.get("commodity", "electricity")
+            if commodity == "electricity":
+                up_price = commitment_upwards_deviation_price
+                down_price = commitment_downwards_deviation_price
+            elif commodity == "gas":
+                if gas_deviation_prices is None:
+                    raise ValueError(
+                        "Gas prices are required in the flex-context to set up gas flow commitments."
+                    )
+                up_price = gas_deviation_prices
+                down_price = gas_deviation_prices
+            else:
+                raise ValueError(
+                    f"Unsupported commodity {commodity} in flex-model. Only 'electricity' and 'gas' are supported."
+                )
 
-            # Set up commitments DataFrame
             commitment = FlowCommitment(
-                name="production peak",
-                quantity=-ems_peak_production,  # production is negative quantity
-                # negative price because peaking in the downwards (production) direction is penalized
-                downwards_deviation_price=-ems_peak_production_price,
-                _type="any",
+                # todo: report aggregate energy costs, too (need to be backwards compatible)
+                name=f"{commodity} energy {d}",
+                quantity=commitment_quantities,
+                upwards_deviation_price=up_price,
+                downwards_deviation_price=down_price,
+                commodity=commodity,
                 index=index,
+                device=d,
+                device_group=commodity,
             )
             commitments.append(commitment)
 
-        # Set up capacity breach commitments and EMS capacity constraints
-        ems_consumption_breach_price = self.flex_context.get(
-            "ems_consumption_breach_price"
-        )
+            # Set up peak commitments
+            if self.flex_context.get("ems_peak_consumption_price") is not None:
+                ems_peak_consumption = get_continuous_series_sensor_or_quantity(
+                    variable_quantity=self.flex_context.get(
+                        "ems_peak_consumption_in_mw"
+                    ),
+                    unit="MW",
+                    query_window=(start, end),
+                    resolution=resolution,
+                    beliefs_before=belief_time,
+                    max_value=np.inf,  # np.nan -> np.inf to ignore commitment if no quantity is given
+                    fill_sides=True,
+                )
+                ems_peak_consumption_price = self.flex_context.get(
+                    "ems_peak_consumption_price"
+                )
+                ems_peak_consumption_price = get_continuous_series_sensor_or_quantity(
+                    variable_quantity=ems_peak_consumption_price,
+                    unit=self.flex_context["shared_currency_unit"] + "/MW",
+                    query_window=(start, end),
+                    resolution=resolution,
+                    beliefs_before=belief_time,
+                    fill_sides=True,
+                )
 
-        ems_production_breach_price = self.flex_context.get(
-            "ems_production_breach_price"
-        )
+                # Set up commitments DataFrame
+                commitment = FlowCommitment(
+                    name=f"consumption peak {d}",
+                    quantity=ems_peak_consumption,
+                    # positive price because breaching in the upwards (consumption) direction is penalized
+                    upwards_deviation_price=ems_peak_consumption_price,
+                    _type="any",
+                    index=index,
+                    device=d,
+                    device_group=flex_model_d["commodity"],
+                )
+                commitments.append(commitment)
+            if self.flex_context.get("ems_peak_production_price") is not None:
+                ems_peak_production = get_continuous_series_sensor_or_quantity(
+                    variable_quantity=self.flex_context.get(
+                        "ems_peak_production_in_mw"
+                    ),
+                    unit="MW",
+                    query_window=(start, end),
+                    resolution=resolution,
+                    beliefs_before=belief_time,
+                    max_value=np.inf,  # np.nan -> np.inf to ignore commitment if no quantity is given
+                    fill_sides=True,
+                )
+                ems_peak_production_price = self.flex_context.get(
+                    "ems_peak_production_price"
+                )
+                ems_peak_production_price = get_continuous_series_sensor_or_quantity(
+                    variable_quantity=ems_peak_production_price,
+                    unit=self.flex_context["shared_currency_unit"] + "/MW",
+                    query_window=(start, end),
+                    resolution=resolution,
+                    beliefs_before=belief_time,
+                    fill_sides=True,
+                )
 
-        ems_constraints = initialize_df(
-            StorageScheduler.COLUMNS, start, end, resolution
-        )
-        if ems_consumption_breach_price is not None:
+                # Set up commitments DataFrame
+                commitment = FlowCommitment(
+                    name=f"production peak {d}",
+                    quantity=-ems_peak_production,  # production is negative quantity
+                    # negative price because peaking in the downwards (production) direction is penalized
+                    downwards_deviation_price=-ems_peak_production_price,
+                    _type="any",
+                    index=index,
+                    device=d,
+                    device_group=flex_model_d["commodity"],
+                )
+                commitments.append(commitment)
 
-            # Convert to Series
-            any_ems_consumption_breach_price = get_continuous_series_sensor_or_quantity(
-                variable_quantity=ems_consumption_breach_price,
-                unit=self.flex_context["shared_currency_unit"] + "/MW",
-                query_window=(start, end),
-                resolution=resolution,
-                beliefs_before=belief_time,
-                fill_sides=True,
-            )
-            all_ems_consumption_breach_price = get_continuous_series_sensor_or_quantity(
-                variable_quantity=ems_consumption_breach_price,
-                unit=self.flex_context["shared_currency_unit"]
-                + "/MW*h",  # from EUR/MWh to EUR/MW/resolution
-                query_window=(start, end),
-                resolution=resolution,
-                beliefs_before=belief_time,
-                fill_sides=True,
+            # Set up capacity breach commitments and EMS capacity constraints
+            ems_consumption_breach_price = self.flex_context.get(
+                "ems_consumption_breach_price"
             )
 
-            # Set up commitments DataFrame to penalize any breach
-            commitment = FlowCommitment(
-                name="any consumption breach",
-                quantity=ems_consumption_capacity,
-                # positive price because breaching in the upwards (consumption) direction is penalized
-                upwards_deviation_price=any_ems_consumption_breach_price,
-                _type="any",
-                index=index,
+            ems_production_breach_price = self.flex_context.get(
+                "ems_production_breach_price"
             )
-            commitments.append(commitment)
 
-            # Set up commitments DataFrame to penalize each breach
-            commitment = FlowCommitment(
-                name="all consumption breaches",
-                quantity=ems_consumption_capacity,
-                # positive price because breaching in the upwards (consumption) direction is penalized
-                upwards_deviation_price=all_ems_consumption_breach_price,
-                index=index,
+            ems_constraints = initialize_df(
+                StorageScheduler.COLUMNS, start, end, resolution
             )
-            commitments.append(commitment)
+            if ems_consumption_breach_price is not None:
 
-            # Take the physical capacity as a hard constraint
-            ems_constraints["derivative max"] = ems_power_capacity_in_mw
-        else:
-            # Take the contracted capacity as a hard constraint
-            ems_constraints["derivative max"] = ems_consumption_capacity
+                # Convert to Series
+                any_ems_consumption_breach_price = (
+                    get_continuous_series_sensor_or_quantity(
+                        variable_quantity=ems_consumption_breach_price,
+                        unit=self.flex_context["shared_currency_unit"] + "/MW",
+                        query_window=(start, end),
+                        resolution=resolution,
+                        beliefs_before=belief_time,
+                        fill_sides=True,
+                    )
+                )
+                all_ems_consumption_breach_price = (
+                    get_continuous_series_sensor_or_quantity(
+                        variable_quantity=ems_consumption_breach_price,
+                        unit=self.flex_context["shared_currency_unit"]
+                        + "/MW*h",  # from EUR/MWh to EUR/MW/resolution
+                        query_window=(start, end),
+                        resolution=resolution,
+                        beliefs_before=belief_time,
+                        fill_sides=True,
+                    )
+                )
 
-        if ems_production_breach_price is not None:
+                # Set up commitments DataFrame to penalize any breach
+                commitment = FlowCommitment(
+                    name=f"any consumption breach {d}",
+                    quantity=ems_consumption_capacity,
+                    # positive price because breaching in the upwards (consumption) direction is penalized
+                    upwards_deviation_price=any_ems_consumption_breach_price,
+                    _type="any",
+                    index=index,
+                    device=d,
+                    device_group=flex_model_d["commodity"],
+                )
+                commitments.append(commitment)
 
-            # Convert to Series
-            any_ems_production_breach_price = get_continuous_series_sensor_or_quantity(
-                variable_quantity=ems_production_breach_price,
-                unit=self.flex_context["shared_currency_unit"] + "/MW",
-                query_window=(start, end),
-                resolution=resolution,
-                beliefs_before=belief_time,
-                fill_sides=True,
-            )
-            all_ems_production_breach_price = get_continuous_series_sensor_or_quantity(
-                variable_quantity=ems_production_breach_price,
-                unit=self.flex_context["shared_currency_unit"]
-                + "/MW*h",  # from EUR/MWh to EUR/MW/resolution
-                query_window=(start, end),
-                resolution=resolution,
-                beliefs_before=belief_time,
-                fill_sides=True,
-            )
+                # Set up commitments DataFrame to penalize each breach
+                commitment = FlowCommitment(
+                    name=f"all consumption breaches {d}",
+                    quantity=ems_consumption_capacity,
+                    # positive price because breaching in the upwards (consumption) direction is penalized
+                    upwards_deviation_price=all_ems_consumption_breach_price,
+                    index=index,
+                    device=d,
+                    device_group=flex_model_d["commodity"],
+                )
+                commitments.append(commitment)
 
-            # Set up commitments DataFrame to penalize any breach
-            commitment = FlowCommitment(
-                name="any production breach",
-                quantity=ems_production_capacity,
-                # negative price because breaching in the downwards (production) direction is penalized
-                downwards_deviation_price=-any_ems_production_breach_price,
-                _type="any",
-                index=index,
-            )
-            commitments.append(commitment)
+                # Take the physical capacity as a hard constraint
+                ems_constraints["derivative max"] = ems_power_capacity_in_mw
+            else:
+                # Take the contracted capacity as a hard constraint
+                ems_constraints["derivative max"] = ems_consumption_capacity
 
-            # Set up commitments DataFrame to penalize each breach
-            commitment = FlowCommitment(
-                name="all production breaches",
-                quantity=ems_production_capacity,
-                # negative price because breaching in the downwards (production) direction is penalized
-                downwards_deviation_price=-all_ems_production_breach_price,
-                index=index,
-            )
-            commitments.append(commitment)
+            if ems_production_breach_price is not None:
 
-            # Take the physical capacity as a hard constraint
-            ems_constraints["derivative min"] = -ems_power_capacity_in_mw
-        else:
-            # Take the contracted capacity as a hard constraint
-            ems_constraints["derivative min"] = ems_production_capacity
+                # Convert to Series
+                any_ems_production_breach_price = (
+                    get_continuous_series_sensor_or_quantity(
+                        variable_quantity=ems_production_breach_price,
+                        unit=self.flex_context["shared_currency_unit"] + "/MW",
+                        query_window=(start, end),
+                        resolution=resolution,
+                        beliefs_before=belief_time,
+                        fill_sides=True,
+                    )
+                )
+                all_ems_production_breach_price = (
+                    get_continuous_series_sensor_or_quantity(
+                        variable_quantity=ems_production_breach_price,
+                        unit=self.flex_context["shared_currency_unit"]
+                        + "/MW*h",  # from EUR/MWh to EUR/MW/resolution
+                        query_window=(start, end),
+                        resolution=resolution,
+                        beliefs_before=belief_time,
+                        fill_sides=True,
+                    )
+                )
+
+                # Set up commitments DataFrame to penalize any breach
+                commitment = FlowCommitment(
+                    name=f"any production breach {d}",
+                    quantity=ems_production_capacity,
+                    # negative price because breaching in the downwards (production) direction is penalized
+                    downwards_deviation_price=-any_ems_production_breach_price,
+                    _type="any",
+                    index=index,
+                    device=d,
+                    device_group=flex_model_d["commodity"],
+                )
+                commitments.append(commitment)
+
+                # Set up commitments DataFrame to penalize each breach
+                commitment = FlowCommitment(
+                    name=f"all production breaches {d}",
+                    quantity=ems_production_capacity,
+                    # negative price because breaching in the downwards (production) direction is penalized
+                    downwards_deviation_price=-all_ems_production_breach_price,
+                    index=index,
+                    device=d,
+                    device_group=flex_model_d["commodity"],
+                )
+                commitments.append(commitment)
+
+                # Take the physical capacity as a hard constraint
+                ems_constraints["derivative min"] = -ems_power_capacity_in_mw
+            else:
+                # Take the contracted capacity as a hard constraint
+                ems_constraints["derivative min"] = ems_production_capacity
 
         # Flow commitments per device
 
@@ -939,6 +1007,7 @@ def _prepare(self, skip_validation: bool = False) -> tuple:  # noqa: C901
 
     def convert_to_commitments(
         self,
+        flex_model,
         **timing_kwargs,
     ) -> list[FlowCommitment]:
         """Convert list of commitment specifications (dicts) to a list of FlowCommitments."""
@@ -976,7 +1045,13 @@ def convert_to_commitments(
             commitment_spec["index"] = initialize_index(
                 start, end, timing_kwargs["resolution"]
             )
-            commitments.append(FlowCommitment(**commitment_spec))
+            for d, flex_model_d in enumerate(flex_model):
+                commitment = FlowCommitment(
+                    device=d,
+                    device_group=flex_model_d["commodity"],
+                    **commitment_spec,
+                )
+                commitments.append(commitment)
 
         return commitments
 
diff --git a/flexmeasures/data/models/planning/tests/test_commitments.py b/flexmeasures/data/models/planning/tests/test_commitments.py
index 0a0ba8b408..c288a4c619 100644
--- a/flexmeasures/data/models/planning/tests/test_commitments.py
+++ b/flexmeasures/data/models/planning/tests/test_commitments.py
@@ -1,12 +1,20 @@
 import pandas as pd
 import numpy as np
 
-from flexmeasures.data.models.planning import Commitment, StockCommitment, FlowCommitment
+from flexmeasures.data.services.utils import get_or_create_model
+from flexmeasures.data.models.planning import (
+    Commitment,
+    StockCommitment,
+    FlowCommitment,
+)
 from flexmeasures.data.models.planning.utils import (
     initialize_index,
     add_tiny_price_slope,
 )
+from flexmeasures.data.models.planning.storage import StorageScheduler
+from flexmeasures.data.models.time_series import Sensor
 from flexmeasures.data.models.planning.linear_optimization import device_scheduler
+from flexmeasures.data.models.generic_assets import GenericAsset, GenericAssetType
 
 
 def test_multi_feed_device_scheduler_shared_buffer():
@@ -118,6 +126,7 @@ def test_multi_feed_device_scheduler_shared_buffer():
                 downwards_deviation_price=prices[device_commodity[d]],
                 device=pd.Series(d, index=index),
                 device_group=device_commodity,
+                commodity=device_commodity[d],
             )
         )
 
@@ -130,6 +139,7 @@ def test_multi_feed_device_scheduler_shared_buffer():
                 downwards_deviation_price=sloped_prices,
                 device=pd.Series(d, index=index),
                 device_group=device_commodity,
+                commodity=device_commodity[d],
             )
         )
 
@@ -306,3 +316,204 @@ def test_each_type_assigns_unique_group_per_slot():
         device=pd.Series("dev", index=idx),
     )
     assert list(c.group) == list(range(len(idx)))
+
+
+def test_two_flexible_assets_with_commodity(app, db):
+    """
+    Test scheduling two flexible assets (battery + heat pump)
+    with explicit electricity commodity.
+    """
+    # ---- asset types
+    battery_type = get_or_create_model(GenericAssetType, name="battery")
+    hp_type = get_or_create_model(GenericAssetType, name="heat-pump")
+
+    # ---- time setup
+    start = pd.Timestamp("2024-01-01T00:00:00+01:00")
+    end = pd.Timestamp("2024-01-02T00:00:00+01:00")
+    resolution = pd.Timedelta("1h")
+
+    # ---- assets
+    battery = GenericAsset(
+        name="Battery",
+        generic_asset_type=battery_type,
+        attributes={"energy-capacity": "100 kWh"},
+    )
+    heat_pump = GenericAsset(
+        name="Heat Pump",
+        generic_asset_type=hp_type,
+        attributes={"energy-capacity": "50 kWh"},
+    )
+    db.session.add_all([battery, heat_pump])
+    db.session.commit()
+
+    # ---- sensors
+    battery_power = Sensor(
+        name="battery power",
+        unit="kW",
+        event_resolution=resolution,
+        generic_asset=battery,
+    )
+    hp_power = Sensor(
+        name="heat pump power",
+        unit="kW",
+        event_resolution=resolution,
+        generic_asset=heat_pump,
+    )
+    db.session.add_all([battery_power, hp_power])
+    db.session.commit()
+
+    # ---- flex-model (list = multi-asset)
+    flex_model = [
+        {
+            # Battery as storage
+            "sensor": battery_power.id,
+            "commodity": "electricity",
+            "soc-at-start": 20.0,
+            "soc-min": 0.0,
+            "soc-max": 100.0,
+            "soc-targets": [{"datetime": "2024-01-01T23:00:00+01:00", "value": 80.0}],
+            "power-capacity": "20 kW",
+            "charging-efficiency": 0.95,
+            "discharging-efficiency": 0.95,
+        },
+        {
+            # Heat pump modeled as storage
+            "sensor": hp_power.id,
+            "commodity": "electricity",
+            "soc-at-start": 10.0,
+            "soc-min": 0.0,
+            "soc-max": 50.0,
+            "soc-targets": [{"datetime": "2024-01-01T23:00:00+01:00", "value": 40.0}],
+            "power-capacity": "10 kW",
+            "production-capacity": "0 kW",
+            "charging-efficiency": 0.95,
+        },
+    ]
+
+    # ---- flex-context (single electricity market)
+    flex_context = {
+        "consumption-price": "100 EUR/MWh",
+        "production-price": "100 EUR/MWh",
+    }
+
+    # ---- run scheduler (use one asset as entry point)
+    scheduler = StorageScheduler(
+        asset_or_sensor=battery,
+        start=start,
+        end=end,
+        resolution=resolution,
+        belief_time=start,
+        flex_model=flex_model,
+        flex_context=flex_context,
+        return_multiple=True,
+    )
+
+    schedules = scheduler.compute(skip_validation=True)
+
+    # ---- assertions
+    assert isinstance(schedules, list)
+    assert len(schedules) >= 2  # at least one schedule per device
+
+
+def test_mixed_gas_and_electricity_assets(app, db):
+    """
+    Test scheduling two flexible assets with different commodities:
+    - Battery (electricity)
+    - Gas boiler (gas)
+    """
+
+    battery_type = get_or_create_model(GenericAssetType, name="battery")
+    boiler_type = get_or_create_model(GenericAssetType, name="gas-boiler")
+
+    start = pd.Timestamp("2024-01-01T00:00:00+01:00")
+    end = pd.Timestamp("2024-01-02T00:00:00+01:00")
+    resolution = pd.Timedelta("1h")
+
+    battery = GenericAsset(
+        name="Battery",
+        generic_asset_type=battery_type,
+        attributes={"energy-capacity": "100 kWh"},
+    )
+
+    gas_boiler = GenericAsset(
+        name="Gas Boiler",
+        generic_asset_type=boiler_type,
+    )
+
+    db.session.add_all([battery, gas_boiler])
+    db.session.commit()
+
+    battery_power = Sensor(
+        name="battery power",
+        unit="kW",
+        event_resolution=resolution,
+        generic_asset=battery,
+    )
+
+    boiler_power = Sensor(
+        name="boiler power",
+        unit="kW",
+        event_resolution=resolution,
+        generic_asset=gas_boiler,
+    )
+
+    db.session.add_all([battery_power, boiler_power])
+    db.session.commit()
+
+    flex_model = [
+        {
+            # Electricity battery
+            "sensor": battery_power.id,
+            "commodity": "electricity",
+            "soc-at-start": 20.0,
+            "soc-min": 0.0,
+            "soc-max": 100.0,
+            "soc-targets": [{"datetime": "2024-01-01T23:00:00+01:00", "value": 80.0}],
+            "power-capacity": "20 kW",
+            "charging-efficiency": 0.95,
+            "discharging-efficiency": 0.95,
+        },
+        {
+            # Gas-powered device (no storage behavior)
+            "sensor": boiler_power.id,
+            "commodity": "gas",
+            "power-capacity": "30 kW",
+            "consumption-capacity": "30 kW",
+            "production-capacity": "0 kW",
+        },
+    ]
+
+    flex_context = {
+        "consumption-price": "100 EUR/MWh",  # electricity price
+        "production-price": "100 EUR/MWh",
+        "gas-price": "50 EUR/MWh",  # gas price
+    }
+
+    scheduler = StorageScheduler(
+        asset_or_sensor=battery,
+        start=start,
+        end=end,
+        resolution=resolution,
+        belief_time=start,
+        flex_model=flex_model,
+        flex_context=flex_context,
+        return_multiple=True,
+    )
+
+    schedules = scheduler.compute(skip_validation=True)
+
+    assert isinstance(schedules, list)
+
+    scheduled_sensors = {
+        entry["sensor"]
+        for entry in schedules
+        if entry.get("name") == "storage_schedule"
+    }
+
+    assert battery_power in scheduled_sensors
+    assert boiler_power in scheduled_sensors
+
+    commitment_costs = [
+        entry for entry in schedules if entry.get("name") == "commitment_costs"
+    ]
+    assert len(commitment_costs) == 1
diff --git a/flexmeasures/data/schemas/scheduling/__init__.py b/flexmeasures/data/schemas/scheduling/__init__.py
index dd2caded11..148f095e44 100644
--- a/flexmeasures/data/schemas/scheduling/__init__.py
+++ b/flexmeasures/data/schemas/scheduling/__init__.py
@@ -299,6 +299,13 @@ class FlexContextSchema(Schema):
         data_key="aggregate-power",
         required=False,
     )
+    gas_price = VariableQuantityField(
+        "/MWh",
+        data_key="gas-price",
+        required=False,
+        return_magnitude=False,
+        metadata=metadata.GAS_PRICE.to_dict(),
+    )
 
     def set_default_breach_prices(
         self, data: dict, fields: list[str], price: ur.Quantity
diff --git a/flexmeasures/data/schemas/scheduling/metadata.py b/flexmeasures/data/schemas/scheduling/metadata.py
index e5a1f26f9d..0e5a2b3552 100644
--- a/flexmeasures/data/schemas/scheduling/metadata.py
+++ b/flexmeasures/data/schemas/scheduling/metadata.py
@@ -52,6 +52,11 @@ def to_dict(self):
     description="The electricity price applied to the site's aggregate production. Can be (a sensor recording) market prices, but also CO₂ intensity—whatever fits your optimization problem, as long as the unit matches the ``consumption-price`` unit. [#old_production_price_field]_",
     example="0.12 EUR/kWh",
 )
+GAS_PRICE = MetaData(
+    description="The gas price applied to the site's aggregate gas consumption. Can be (a sensor recording) market prices, but also CO₂ intensity—whatever fits your optimization problem",
+    example={"sensor": 6},
+    # example="0.09 EUR/kWh",
+)
 SITE_POWER_CAPACITY = MetaData(
     description="""Maximum achievable power at the site's grid connection point, in either direction.
 Becomes a hard constraint in the optimization problem, which is especially suitable for physical limitations. [#asymmetric]_ [#minimum_capacity_overlap]_
diff --git a/flexmeasures/data/schemas/scheduling/storage.py b/flexmeasures/data/schemas/scheduling/storage.py
index 9eaf1dcf7c..1154c4c97f 100644
--- a/flexmeasures/data/schemas/scheduling/storage.py
+++ b/flexmeasures/data/schemas/scheduling/storage.py
@@ -25,6 +25,8 @@
     is_energy_unit,
 )
 
+ALLOWED_COMMODITIES = {"electricity", "gas"}
+
 #  Telling type hints what to expect after schema parsing
 SoCTarget = TypedDict(
     "SoCTarget",
@@ -222,6 +224,12 @@ class StorageFlexModelSchema(Schema):
         validate=validate.Length(min=1),
         metadata=metadata.SOC_USAGE.to_dict(),
     )
+    commodity = fields.Str(
+        required=False,
+        load_default="electricity",
+        validate=OneOf(["electricity", "gas"]),
+        metadata=dict(description="Commodity label for this device/asset."),
+    )
 
     def __init__(
         self,
@@ -343,6 +351,11 @@ def check_redundant_efficiencies(self, data: dict, **kwargs):
                     f"Fields `{field}` and `roundtrip_efficiency` are mutually exclusive."
                 )
 
+    @validates("commodity")
+    def validate_commodity(self, commodity: str, **kwargs):
+        if not isinstance(commodity, str) or not commodity.strip():
+            raise ValidationError("commodity must be a non-empty string.")
+
     @post_load
     def post_load_sequence(self, data: dict, **kwargs) -> dict:
         """Perform some checks and corrections after we loaded."""
@@ -492,6 +505,13 @@ class DBStorageFlexModelSchema(Schema):
         metadata={"deprecated field": "production_capacity"},
     )
 
+    commodity = fields.Str(
+        required=False,
+        load_default="electricity",
+        validate=OneOf(["electricity", "gas"]),
+        metadata=dict(description="Commodity label for this device/asset."),
+    )
+
     mapped_schema_keys: dict
 
     def __init__(self, *args, **kwargs):
diff --git a/flexmeasures/ui/static/openapi-specs.json b/flexmeasures/ui/static/openapi-specs.json
index ea91c572f7..6224dafe03 100644
--- a/flexmeasures/ui/static/openapi-specs.json
+++ b/flexmeasures/ui/static/openapi-specs.json
@@ -4106,6 +4106,13 @@
           },
           "aggregate-power": {
             "$ref": "#/components/schemas/SensorReference"
+          },
+          "gas-price": {
+            "description": "The gas price applied to the site's aggregate gas consumption. Can be (a sensor recording) market prices, but also CO\u2082 intensity\u2014whatever fits your optimization problem",
+            "example": {
+              "sensor": 6
+            },
+            "$ref": "#/components/schemas/VariableQuantityOpenAPI"
           }
         },
         "additionalProperties": false
@@ -5396,6 +5403,15 @@
               }
             ],
             "items": {}
+          },
+          "commodity": {
+            "type": "string",
+            "default": "electricity",
+            "enum": [
+              "electricity",
+              "gas"
+            ],
+            "description": "Commodity label for this device/asset."
           }
         },
         "additionalProperties": false