diff --git a/CDB_study.slurm b/CDB_study.slurm
index ff7ac0f..628326b 100644
--- a/CDB_study.slurm
+++ b/CDB_study.slurm
@@ -37,7 +37,7 @@ if [[ $SLURM_ARRAY_TASK_ID -ge 0 && $SLURM_ARRAY_TASK_ID -le 3 ]]; then
     DIM=${DIMS[$SLURM_ARRAY_TASK_ID]}
     echo "Running Mode: $MODE | Dimension: $DIM"
 
-    python3 dynamicalgorithmselection/main.py ${PORTFOLIO_STR}_PG_${MODE}_${CDB_VAL}_${DIM} \
+    python3 dynamicalgorithmselection/main.py ${PORTFOLIO_STR}_PG_${MODE}_${CDB_VAL}_DIM${DIM} \
       -p "${PORTFOLIO[@]}" -r ELA --mode $MODE --dimensionality $DIM \
       --cdb $CDB_VAL --n_epochs 3 --agent policy-gradient
 
@@ -47,7 +47,7 @@ elif [[ $SLURM_ARRAY_TASK_ID -ge 4 && $SLURM_ARRAY_TASK_ID -le 7 ]]; then
     DIM=${DIMS[$((SLURM_ARRAY_TASK_ID - 4))]}
     echo "Running Mode: $MODE | Dimension: $DIM"
 
-    python3 dynamicalgorithmselection/main.py ${PORTFOLIO_STR}_PG_${MODE}_${CDB_VAL}_${DIM} \
+    python3 dynamicalgorithmselection/main.py ${PORTFOLIO_STR}_PG_${MODE}_${CDB_VAL}_DIM${DIM} \
       -p "${PORTFOLIO[@]}" -r ELA --mode $MODE --dimensionality $DIM \
       --cdb $CDB_VAL --n_epochs 3 --agent policy-gradient
 
diff --git a/README.md b/README.md
index 5469d65..323a285 100644
--- a/README.md
+++ b/README.md
@@ -73,7 +73,7 @@ uv run das <name> [options]
 | `-x`, `--cdb`                      | `float`     | `1.0`                       | **Checkpoint Division Exponent**; determines how quickly checkpoint length increases.                            |
 | `-r`, `--state-representation`     | `str`       | `ELA`                       | Method used to extract features from the algorithm population.                                                   |
 | `-d`, `--force-restarts`           | `bool`      | `False`                     | Enable selection of forcibly restarting optimizers.                                                              |
-| `-D`, `--dimensionality`           | `int`       | `None`                      | Dimensionality of problems.                                                                                      |
+| `-D`, `--dimensionality`           | `list[int]` | `[2, 3, 5, 10, 20, 40]`     | Dimensionality of problems.                                                                                      |
 | `-E`, `--n_epochs`                 | `int`       | `1`                         | Number of training epochs.                                                                                       |
 | `-O`, `--reward-option`            | `int`       | `1`                         | ID of method used to compute reward.                                                                             |
 
diff --git a/dynamicalgorithmselection/agents/RLDAS_agent.py b/dynamicalgorithmselection/agents/RLDAS_agent.py
index f02bc47..7cfc97a 100644
--- a/dynamicalgorithmselection/agents/RLDAS_agent.py
+++ b/dynamicalgorithmselection/agents/RLDAS_agent.py
@@ -272,7 +272,6 @@ def optimize(self, fitness_function=None, args=None):
 
             self._n_generations += 1
             self._print_verbose_info(fitness, self.best_so_far_y)
-        print(self._n_generations)
         fes_end = self.n_function_evaluations
         speed_factor = self.max_function_evaluations / fes_end
 
diff --git a/dynamicalgorithmselection/agents/agent_utils.py b/dynamicalgorithmselection/agents/agent_utils.py
index 0bb2f23..019eefa 100644
--- a/dynamicalgorithmselection/agents/agent_utils.py
+++ b/dynamicalgorithmselection/agents/agent_utils.py
@@ -1,5 +1,3 @@
-from typing import Optional
-
 import numpy as np
 
 MAX_DIM = 40
@@ -14,7 +12,6 @@ def get_runtime_stats(
     """
     :param fitness_history: list of tuples [fe, fitness] with only points where best so far fitness improved
     :param function_evaluations: max number of function evaluations during run.
-    :param checkpoints: list of checkpoints by their n_function_evaluations
     :return: dictionary of selected run statistics, ready to dump
     """
     area_under_optimization_curve = 0.0
@@ -43,7 +40,6 @@ def get_extreme_stats(
     """
     :param fitness_histories: list of lists of tuples [fe, fitness] with only points where best so far fitness improved for each algorithm
     :param function_evaluations: max number of function evaluations during run.
-    :param checkpoints: list of checkpoints by their n_function_evaluations
     :return: dictionary of selected run statistics, ready to dump
     """
     all_improvements = []
diff --git a/portfolio_study.slurm b/portfolio_study.slurm
index 4282edd..d320d2f 100644
--- a/portfolio_study.slurm
+++ b/portfolio_study.slurm
@@ -9,17 +9,12 @@
 #SBATCH --partition=plgrid-gpu-a100
 #SBATCH --array=0-9           # 10 tasks total
 
-CDB_VAL=${1:-1.5}
+REWARD_OPTION=${1:-1}
 
-if [ "$#" -gt 0 ]; then
-    shift
-fi
+CDB_VAL=1.5
+
+PORTFOLIO=('MADDE' 'CMAES' 'SPSO')
 
-if [ "$#" -eq 0 ]; then
-    PORTFOLIO=('MADDE' 'CMAES' 'SPSO')
-else
-    PORTFOLIO=("$@")
-fi
 PORTFOLIO_STR=$(IFS="_"; echo "${PORTFOLIO[*]}")
 
 
@@ -37,7 +32,7 @@ if [[ $SLURM_ARRAY_TASK_ID -ge 0 && $SLURM_ARRAY_TASK_ID -le 3 ]]; then
     DIM=${DIMS[$SLURM_ARRAY_TASK_ID]}
     echo "Running Mode: $MODE | Dimension: $DIM"
 
-    python3 dynamicalgorithmselection/main.py ${PORTFOLIO_STR}_PG_${MODE}_${CDB_VAL}_${DIM} \
+    python3 dynamicalgorithmselection/main.py ${PORTFOLIO_STR}_PG_${MODE}_$_REWARD_${REWARD_OPTION}_DIM${DIM} \
       -p "${PORTFOLIO[@]}" -r ELA --mode $MODE --dimensionality $DIM \
       --cdb $CDB_VAL --n_epochs 3 --agent policy-gradient
 
@@ -47,7 +42,7 @@ elif [[ $SLURM_ARRAY_TASK_ID -ge 4 && $SLURM_ARRAY_TASK_ID -le 7 ]]; then
     DIM=${DIMS[$((SLURM_ARRAY_TASK_ID - 4))]}
     echo "Running Mode: $MODE | Dimension: $DIM"
 
-    python3 dynamicalgorithmselection/main.py ${PORTFOLIO_STR}_PG_${MODE}_${CDB_VAL}_${DIM} \
+    python3 dynamicalgorithmselection/main.py ${PORTFOLIO_STR}_PG_${MODE}_REWARD_${REWARD_OPTION}_DIM${DIM} \
       -p "${PORTFOLIO[@]}" -r ELA --mode $MODE --dimensionality $DIM \
       --cdb $CDB_VAL --n_epochs 3 --agent policy-gradient
 
@@ -55,13 +50,13 @@ elif [[ $SLURM_ARRAY_TASK_ID -ge 4 && $SLURM_ARRAY_TASK_ID -le 7 ]]; then
 elif [[ $SLURM_ARRAY_TASK_ID -eq 8 ]]; then
     MODE="CV-LOIO"
     echo "Running Mode: $MODE | Multidimensional PG"
-    python3 dynamicalgorithmselection/main.py ${PORTFOLIO_STR}_PG_MULTIDIMENSIONAL_${MODE}_${CDB_VAL} \
+    python3 dynamicalgorithmselection/main.py ${PORTFOLIO_STR}_PG_MULTIDIMENSIONAL_${MODE}_REWARD_${REWARD_OPTION} \
       -p "${PORTFOLIO[@]}" -r ELA --mode $MODE --cdb $CDB_VAL --agent policy-gradient
 
 # 4. Multidimensional CV-LOPO (Index 9)
 elif [[ $SLURM_ARRAY_TASK_ID -eq 9 ]]; then
     MODE="CV-LOPO"
     echo "Running Mode: $MODE | Multidimensional PG"
-    python3 dynamicalgorithmselection/main.py ${PORTFOLIO_STR}_PG_MULTIDIMENSIONAL_${MODE}_${CDB_VAL} \
+    python3 dynamicalgorithmselection/main.py ${PORTFOLIO_STR}_PG_MULTIDIMENSIONAL_${MODE}_REWARD_${REWARD_OPTION} \
       -p "${PORTFOLIO[@]}" -r ELA --mode $MODE --cdb $CDB_VAL --agent policy-gradient
 fi
\ No newline at end of file
diff --git a/reward_study.slurm b/reward_study.slurm
new file mode 100644
index 0000000..ff7ac0f
--- /dev/null
+++ b/reward_study.slurm
@@ -0,0 +1,67 @@
+#!/bin/bash
+#SBATCH --job-name=rl_das_experiment
+#SBATCH --output=logs/experiment_%A_%a.out
+#SBATCH --error=logs/experiment_%A_%a.err
+#SBATCH --ntasks=1
+#SBATCH --cpus-per-task=1
+#SBATCH --mem=32G
+#SBATCH --time=48:00:00
+#SBATCH --partition=plgrid-gpu-a100
+#SBATCH --array=0-9           # 10 tasks total
+
+CDB_VAL=${1:-1.5}
+
+if [ "$#" -gt 0 ]; then
+    shift
+fi
+
+if [ "$#" -eq 0 ]; then
+    PORTFOLIO=('JDE21' 'MADDE' 'NL_SHADE_RSP')
+else
+    PORTFOLIO=("$@")
+fi
+PORTFOLIO_STR=$(IFS="_"; echo "${PORTFOLIO[*]}")
+
+
+# CONFIGURATION
+ENV_PATH="$SCRATCH/DynamicAlgorithmSelection/.venv/bin/activate"
+source "$ENV_PATH"
+mkdir -p logs
+
+# Array of Dimensions
+DIMS=(2 3 5 10)
+
+# 1. Dimension-specific CV-LOIO (Indices 0-3)
+if [[ $SLURM_ARRAY_TASK_ID -ge 0 && $SLURM_ARRAY_TASK_ID -le 3 ]]; then
+    MODE="CV-LOIO"
+    DIM=${DIMS[$SLURM_ARRAY_TASK_ID]}
+    echo "Running Mode: $MODE | Dimension: $DIM"
+
+    python3 dynamicalgorithmselection/main.py ${PORTFOLIO_STR}_PG_${MODE}_${CDB_VAL}_${DIM} \
+      -p "${PORTFOLIO[@]}" -r ELA --mode $MODE --dimensionality $DIM \
+      --cdb $CDB_VAL --n_epochs 3 --agent policy-gradient
+
+# 2. Dimension-specific CV-LOPO (Indices 4-7)
+elif [[ $SLURM_ARRAY_TASK_ID -ge 4 && $SLURM_ARRAY_TASK_ID -le 7 ]]; then
+    MODE="CV-LOPO"
+    DIM=${DIMS[$((SLURM_ARRAY_TASK_ID - 4))]}
+    echo "Running Mode: $MODE | Dimension: $DIM"
+
+    python3 dynamicalgorithmselection/main.py ${PORTFOLIO_STR}_PG_${MODE}_${CDB_VAL}_${DIM} \
+      -p "${PORTFOLIO[@]}" -r ELA --mode $MODE --dimensionality $DIM \
+      --cdb $CDB_VAL --n_epochs 3 --agent policy-gradient
+
+# 3. Multidimensional CV-LOIO (Index 8)
+elif [[ $SLURM_ARRAY_TASK_ID -eq 8 ]]; then
+    MODE="CV-LOIO"
+    echo "Running Mode: $MODE | Multidimensional PG"
+    python3 dynamicalgorithmselection/main.py ${PORTFOLIO_STR}_PG_MULTIDIMENSIONAL_${MODE}_${CDB_VAL} \
+      -p "${PORTFOLIO[@]}" -r ELA --mode $MODE --cdb $CDB_VAL --agent policy-gradient
+
+# 4. Multidimensional CV-LOPO (Index 9)
+elif [[ $SLURM_ARRAY_TASK_ID -eq 9 ]]; then
+    MODE="CV-LOPO"
+    echo "Running Mode: $MODE | Multidimensional PG"
+    python3 dynamicalgorithmselection/main.py ${PORTFOLIO_STR}_PG_MULTIDIMENSIONAL_${MODE}_${CDB_VAL} \
+      -p "${PORTFOLIO[@]}" -r ELA --mode $MODE --cdb $CDB_VAL --agent policy-gradient
+fi
\ No newline at end of file
diff --git a/runner.slurm b/runner.slurm
index d0bbca4..9aeb115 100644
--- a/runner.slurm
+++ b/runner.slurm
@@ -9,15 +9,13 @@
 #SBATCH --partition=plgrid-gpu-a100
 #SBATCH --array=0-23           # Increased to 24 tasks total to split sequential runs
 
+# 1st argument: CDB_VAL (Default: 1.5)
 CDB_VAL=${1:-1.5}
 
-if [ "$#" -gt 0 ]; then
-    shift
-fi
-
-# Store the remaining arguments as an array called PORTFOLIO.
-# If no additional arguments were provided, fall back to your default.
+# 2nd argument: SEED (Default: 42)
+SEED=${2:-42}
 
+# Fixed PORTFOLIO variable
 PORTFOLIO=('JDE21' 'MADDE' 'NL_SHADE_RSP')
 
 # CONFIGURATION
@@ -31,72 +29,72 @@ DIMS=(2 3 5 10)
 # 1. Dimension-specific CV-LOIO | RL-DAS (Indices 0-3)
 if [[ $SLURM_ARRAY_TASK_ID -ge 0 && $SLURM_ARRAY_TASK_ID -le 3 ]]; then
     MODE="CV-LOIO"
-    DIM=${DIMS[$SLURM_ARRAY_TASK_ID]}
+    DIM=DIM${DIMS[$SLURM_ARRAY_TASK_ID]}
     echo "Running Mode: $MODE | Agent: RL-DAS | Dimension: $DIM"
 
-    python3 dynamicalgorithmselection/main.py JDE21_MADDE_NL_SHADE_RSP_RLDAS_${MODE}_${DIM} \
-      -p "${PORTFOLIO[@]}"  --mode $MODE --dimensionality $DIM --n_epochs 40 --agent RL-DAS
+    python3 dynamicalgorithmselection/main.py JDE21_MADDE_NL_SHADE_RSP_RLDAS_${MODE}_DIM${DIM}_SEED${SEED} \
+      -p "${PORTFOLIO[@]}"  --mode $MODE --dimensionality $DIM --n_epochs 40 --agent RL-DAS -S "$SEED"
 
 # 2. Dimension-specific CV-LOIO | Policy Gradient (Indices 4-7)
 elif [[ $SLURM_ARRAY_TASK_ID -ge 4 && $SLURM_ARRAY_TASK_ID -le 7 ]]; then
     MODE="CV-LOIO"
-    DIM=${DIMS[$((SLURM_ARRAY_TASK_ID - 4))]}
+    DIM=DIM${DIMS[$((SLURM_ARRAY_TASK_ID - 4))]}
     echo "Running Mode: $MODE | Agent: Policy Gradient | Dimension: $DIM"
 
-    python3 dynamicalgorithmselection/main.py JDE21_MADDE_NL_SHADE_RSP_PG_${MODE}_${CDB_VAL}_${DIM} \
+    python3 dynamicalgorithmselection/main.py JDE21_MADDE_NL_SHADE_RSP_PG_${MODE}_${CDB_VAL}_DIM${DIM}_SEED${SEED} \
       -p "${PORTFOLIO[@]}" -r custom --mode $MODE --dimensionality $DIM \
-      --cdb $CDB_VAL --n_epochs 3 --agent policy-gradient
+      --cdb $CDB_VAL --n_epochs 3 --agent policy-gradient -S "$SEED"
 
 # 3. Dimension-specific CV-LOPO | RL-DAS (Indices 8-11)
 elif [[ $SLURM_ARRAY_TASK_ID -ge 8 && $SLURM_ARRAY_TASK_ID -le 11 ]]; then
     MODE="CV-LOPO"
-    DIM=${DIMS[$((SLURM_ARRAY_TASK_ID - 8))]}
+    DIM=DIM${DIMS[$((SLURM_ARRAY_TASK_ID - 8))]}
     echo "Running Mode: $MODE | Agent: RL-DAS | Dimension: $DIM"
 
-    python3 dynamicalgorithmselection/main.py JDE21_MADDE_NL_SHADE_RSP_RLDAS_${MODE}_${DIM} \
-      -p "${PORTFOLIO[@]}"  --mode $MODE --dimensionality $DIM --n_epochs 40 --agent RL-DAS
+    python3 dynamicalgorithmselection/main.py JDE21_MADDE_NL_SHADE_RSP_RLDAS_${MODE}_DIM${DIM}_SEED${SEED} \
+      -p "${PORTFOLIO[@]}"  --mode $MODE --dimensionality $DIM --n_epochs 40 --agent RL-DAS -S "$SEED"
 
 # 4. Dimension-specific CV-LOPO | Policy Gradient (Indices 12-15)
 elif [[ $SLURM_ARRAY_TASK_ID -ge 12 && $SLURM_ARRAY_TASK_ID -le 15 ]]; then
     MODE="CV-LOPO"
-    DIM=${DIMS[$((SLURM_ARRAY_TASK_ID - 12))]}
+    DIM=DIM${DIMS[$((SLURM_ARRAY_TASK_ID - 12))]}
     echo "Running Mode: $MODE | Agent: Policy Gradient | Dimension: $DIM"
 
-    python3 dynamicalgorithmselection/main.py JDE21_MADDE_NL_SHADE_RSP_PG_${MODE}_${CDB_VAL}_${DIM} \
-      -p "${PORTFOLIO[@]}" -r custom --mode $MODE --dimensionality $DIM \
-      --cdb $CDB_VAL --n_epochs 3 --agent policy-gradient
+    python3 dynamicalgorithmselection/main.py JDE21_MADDE_NL_SHADE_RSP_PG_${MODE}_${CDB_VAL}_DIM${DIM}_SEED${SEED} \
+      -p "${PORTFOLIO[@]}" --mode $MODE --dimensionality $DIM \
+      --cdb $CDB_VAL --n_epochs 3 --agent policy-gradient -S "$SEED"
 
 # 5. Dimension-specific RL-DAS-random (Indices 16-19)
 elif [[ $SLURM_ARRAY_TASK_ID -ge 16 && $SLURM_ARRAY_TASK_ID -le 19 ]]; then
-    DIM=${DIMS[$((SLURM_ARRAY_TASK_ID - 16))]}
+    DIM=DIM${DIMS[$((SLURM_ARRAY_TASK_ID - 16))]}
     echo "Running Mode: Random Agent - RLDAS variant | Dimension: $DIM"
 
-    python3 dynamicalgorithmselection/main.py JDE21_MADDE_NL_SHADE_RSP_RANDOM_DAS_${DIM} \
-      -p 'JDE21' 'MADDE' 'NL_SHADE_RSP' --agent RL-DAS-random --dimensionality $DIM
+    python3 dynamicalgorithmselection/main.py JDE21_MADDE_NL_SHADE_RSP_RANDOM_DAS_DIM${DIM}_SEED${SEED} \
+      -p "${PORTFOLIO[@]}" --agent RL-DAS-random --dimensionality $DIM -S "$SEED"
 
 # 6. Multidimensional CV-LOIO (Index 20)
 elif [[ $SLURM_ARRAY_TASK_ID -eq 20 ]]; then
     MODE="CV-LOIO"
     echo "Running Mode: $MODE | Multidimensional PG"
-    python3 dynamicalgorithmselection/main.py JDE21_MADDE_NL_SHADE_RSP_PG_MULTIDIMENSIONAL_${MODE}_${CDB_VAL} \
-      -p "${PORTFOLIO[@]}" -r custom --mode $MODE --cdb $CDB_VAL --agent policy-gradient
+    python3 dynamicalgorithmselection/main.py JDE21_MADDE_NL_SHADE_RSP_PG_MULTIDIMENSIONAL_${MODE}_${CDB_VAL}_SEED${SEED} \
+      -p "${PORTFOLIO[@]}" --mode $MODE --cdb $CDB_VAL --agent policy-gradient -S "$SEED"
 
 # 7. Multidimensional CV-LOPO (Index 21)
 elif [[ $SLURM_ARRAY_TASK_ID -eq 21 ]]; then
     MODE="CV-LOPO"
     echo "Running Mode: $MODE | Multidimensional PG"
-    python3 dynamicalgorithmselection/main.py JDE21_MADDE_NL_SHADE_RSP_PG_MULTIDIMENSIONAL_${MODE}_${CDB_VAL} \
-      -p "${PORTFOLIO[@]}" -r custom --mode $MODE --cdb $CDB_VAL --agent policy-gradient
+    python3 dynamicalgorithmselection/main.py JDE21_MADDE_NL_SHADE_RSP_PG_MULTIDIMENSIONAL_${MODE}_${CDB_VAL}_SEED${SEED} \
+      -p "${PORTFOLIO[@]}" --mode $MODE --cdb $CDB_VAL --agent policy-gradient -S "$SEED"
 
 # 8. Global Random Agent (Index 22)
 elif [[ $SLURM_ARRAY_TASK_ID -eq 22 ]]; then
     echo "Running Mode: Global Random Agent"
-    python3 dynamicalgorithmselection/main.py JDE21_MADDE_NL_SHADE_RSP_RANDOM_${CDB_VAL} \
-      -p "${PORTFOLIO[@]}" --cdb $CDB_VAL --agent random
+    python3 dynamicalgorithmselection/main.py JDE21_MADDE_NL_SHADE_RSP_RANDOM_${CDB_VAL}_SEED${SEED} \
+      -p "${PORTFOLIO[@]}" --cdb $CDB_VAL --agent random -S "$SEED"
 
 # 9. Global Baselines (Index 23)
 elif [[ $SLURM_ARRAY_TASK_ID -eq 23 ]]; then
     echo "Running Mode: Baselines"
     python3 dynamicalgorithmselection/main.py BASELINES \
-      -p "${PORTFOLIO[@]}" --mode baselines
+      -p "${PORTFOLIO[@]}" --mode baselines -S "$SEED"
 fi
\ No newline at end of file
diff --git a/single_algorithm_CDB_study.slurm b/single_algorithm_CDB_study.slurm
new file mode 100644
index 0000000..c7c0448
--- /dev/null
+++ b/single_algorithm_CDB_study.slurm
@@ -0,0 +1,62 @@
+#!/bin/bash
+#SBATCH --job-name=rl_das_experiment
+#SBATCH --output=logs/experiment_%A_%a.out
+#SBATCH --error=logs/experiment_%A_%a.err
+#SBATCH --ntasks=1
+#SBATCH --cpus-per-task=1
+#SBATCH --mem=32G
+#SBATCH --time=48:00:00
+#SBATCH --partition=plgrid-gpu-a100
+#SBATCH --array=0-9           # 10 tasks total
+
+REWARD_OPTION=${1:-1}
+
+CDB_VAL=1.5
+
+PORTFOLIO=('MADDE')
+
+PORTFOLIO_STR=$(IFS="_"; echo "${PORTFOLIO[*]}")
+
+
+# CONFIGURATION
+ENV_PATH="$SCRATCH/DynamicAlgorithmSelection/.venv/bin/activate"
+source "$ENV_PATH"
+mkdir -p logs
+
+# Array of Dimensions
+DIMS=(2 3 5 10)
+
+# 1. Dimension-specific CV-LOIO (Indices 0-3)
+if [[ $SLURM_ARRAY_TASK_ID -ge 0 && $SLURM_ARRAY_TASK_ID -le 3 ]]; then
+    MODE="CV-LOIO"
+    DIM=${DIMS[$SLURM_ARRAY_TASK_ID]}
+    echo "Running Mode: $MODE | Dimension: $DIM"
+
+    python3 dynamicalgorithmselection/main.py ${PORTFOLIO_STR}_PG_${MODE}_DIM${DIM} \
+      -p "${PORTFOLIO[@]}" -r ELA --mode $MODE --dimensionality $DIM \
+      --cdb $CDB_VAL --n_epochs 3 --agent policy-gradient
+
+# 2. Dimension-specific CV-LOPO (Indices 4-7)
+elif [[ $SLURM_ARRAY_TASK_ID -ge 4 && $SLURM_ARRAY_TASK_ID -le 7 ]]; then
+    MODE="CV-LOPO"
+    DIM=${DIMS[$((SLURM_ARRAY_TASK_ID - 4))]}
+    echo "Running Mode: $MODE | Dimension: $DIM"
+
+    python3 dynamicalgorithmselection/main.py ${PORTFOLIO_STR}_PG_${MODE}_DIM${DIM} \
+      -p "${PORTFOLIO[@]}" -r ELA --mode $MODE --dimensionality $DIM \
+      --cdb $CDB_VAL --n_epochs 3 --agent policy-gradient
+
+# 3. Multidimensional CV-LOIO (Index 8)
+elif [[ $SLURM_ARRAY_TASK_ID -eq 8 ]]; then
+    MODE="CV-LOIO"
+    echo "Running Mode: $MODE | Multidimensional PG"
+    python3 dynamicalgorithmselection/main.py ${PORTFOLIO_STR}_PG_MULTIDIMENSIONAL_${MODE} \
+      -p "${PORTFOLIO[@]}" -r ELA --mode $MODE --cdb $CDB_VAL --agent policy-gradient
+
+# 4. Multidimensional CV-LOPO (Index 9)
+elif [[ $SLURM_ARRAY_TASK_ID -eq 9 ]]; then
+    MODE="CV-LOPO"
+    echo "Running Mode: $MODE | Multidimensional PG"
+    python3 dynamicalgorithmselection/main.py ${PORTFOLIO_STR}_PG_MULTIDIMENSIONAL_${MODE} \
+      -p "${PORTFOLIO[@]}" -r ELA --mode $MODE --cdb $CDB_VAL --agent policy-gradient
+fi
\ No newline at end of file