diff --git a/app/static/src/app/components/basic/BasicApp.vue b/app/static/src/app/components/basic/BasicApp.vue
index 6ee80fe4a..49e67d111 100644
--- a/app/static/src/app/components/basic/BasicApp.vue
+++ b/app/static/src/app/components/basic/BasicApp.vue
@@ -21,6 +21,9 @@
         <template v-slot:Sensitivity>
           <sensitivity-tab></sensitivity-tab>
         </template>
+        <template v-slot:Multi-sensitivity>
+          <multi-sensitivity-tab></multi-sensitivity-tab>
+        </template>
       </wodin-tabs>
     </template>
   </wodin-app>
@@ -35,10 +38,11 @@ import CodeTab from "../code/CodeTab.vue";
 import RunTab from "../run/RunTab.vue";
 import OptionsTab from "../options/OptionsTab.vue";
 import SensitivityTab from "../sensitivity/SensitivityTab.vue";
+import MultiSensitivityTab from "../multiSensitivity/MultiSensitivityTab.vue";
 import { AppStateMutation } from "../../store/appState/mutations";
 import { VisualisationTab } from "../../store/appState/state";
 import HelpTab from "../help/HelpTab.vue";
-import includeHelpTab from "../mixins/includeHelpTab";
+import includeConfiguredTabs from "../mixins/includeConfiguredTabs";
 
 export default defineComponent({
     name: "BasicApp",
@@ -48,18 +52,20 @@ export default defineComponent({
         RunTab,
         OptionsTab,
         SensitivityTab,
+        MultiSensitivityTab,
         WodinApp,
         WodinTabs
     },
     setup() {
         const store = useStore();
         const rightTabSelected = (tab: string) => { store.commit(AppStateMutation.SetOpenVisualisationTab, tab); };
-        const { helpTabName, rightTabNames } = includeHelpTab(store,
+        const { helpTabName, multiSensitivityTabName, rightTabNames } = includeConfiguredTabs(store,
             [VisualisationTab.Run, VisualisationTab.Sensitivity]);
 
         return {
             rightTabSelected,
             helpTabName,
+            multiSensitivityTabName,
             rightTabNames
         };
     }
diff --git a/app/static/src/app/components/fit/FitApp.vue b/app/static/src/app/components/fit/FitApp.vue
index d8b821ff8..cf1b37855 100644
--- a/app/static/src/app/components/fit/FitApp.vue
+++ b/app/static/src/app/components/fit/FitApp.vue
@@ -27,6 +27,9 @@
         <template v-slot:Sensitivity>
           <sensitivity-tab></sensitivity-tab>
         </template>
+        <template v-slot:Multi-sensitivity>
+          <multi-sensitivity-tab></multi-sensitivity-tab>
+        </template>
       </wodin-tabs>
     </template>
   </wodin-app>
@@ -35,6 +38,7 @@
 <script lang="ts">
 import { defineComponent } from "vue";
 import { useStore } from "vuex";
+import MultiSensitivityTab from "@/app/components/multiSensitivity/MultiSensitivityTab.vue";
 import WodinApp from "../WodinApp.vue";
 import WodinTabs from "../WodinTabs.vue";
 import CodeTab from "../code/CodeTab.vue";
@@ -46,11 +50,12 @@ import OptionsTab from "../options/OptionsTab.vue";
 import SensitivityTab from "../sensitivity/SensitivityTab.vue";
 import { VisualisationTab } from "../../store/appState/state";
 import { AppStateMutation } from "../../store/appState/mutations";
-import includeHelpTab from "../mixins/includeHelpTab";
+import includeConfiguredTabs from "../mixins/includeConfiguredTabs";
 
 export default defineComponent({
     name: "FitApp",
     components: {
+        MultiSensitivityTab,
         CodeTab,
         DataTab,
         FitTab,
@@ -67,7 +72,7 @@ export default defineComponent({
         const rightTabSelected = (tab: string) => {
             store.commit(AppStateMutation.SetOpenVisualisationTab, tab);
         };
-        const { helpTabName, rightTabNames } = includeHelpTab(store,
+        const { helpTabName, rightTabNames } = includeConfiguredTabs(store,
             [VisualisationTab.Run, VisualisationTab.Fit, VisualisationTab.Sensitivity]);
 
         return {
diff --git a/app/static/src/app/components/mixins/includeHelpTab.ts b/app/static/src/app/components/mixins/includeConfiguredTabs.ts
similarity index 54%
rename from app/static/src/app/components/mixins/includeHelpTab.ts
rename to app/static/src/app/components/mixins/includeConfiguredTabs.ts
index 7bd734bcf..6c17f70ca 100644
--- a/app/static/src/app/components/mixins/includeHelpTab.ts
+++ b/app/static/src/app/components/mixins/includeConfiguredTabs.ts
@@ -1,8 +1,8 @@
 import { Store } from "vuex";
 import { computed } from "vue";
-import { AppState } from "../../store/appState/state";
+import { AppState, VisualisationTab } from "../../store/appState/state";
 
-export default (store: Store<AppState>, nonHelpTabNames: string[]) => {
+export default (store: Store<AppState>, fixedTabNames: string[]) => {
     const helpTabName = computed(() => {
         if (store.state.config?.help?.markdown?.length) {
             return store.state.config.help.tabName || "Explanation"; // default if markdown but no tab name
@@ -10,8 +10,14 @@ export default (store: Store<AppState>, nonHelpTabNames: string[]) => {
         // do not show tab if no markdown
         return null;
     });
+    const multiSensitivityTabName = computed(() => {
+        return store.state.config?.multiSensitivity ? VisualisationTab.MultiSensitivity : null;
+    });
     const rightTabNames = computed(() => {
-        const result = [...nonHelpTabNames];
+        const result = [...fixedTabNames];
+        if (multiSensitivityTabName.value) {
+            result.push(multiSensitivityTabName.value);
+        }
         if (helpTabName.value) {
             result.unshift(helpTabName.value);
         }
@@ -20,6 +26,7 @@ export default (store: Store<AppState>, nonHelpTabNames: string[]) => {
 
     return {
         helpTabName,
+        multiSensitivityTabName,
         rightTabNames
     };
 };
diff --git a/app/static/src/app/components/multiSensitivity/MultiSensitivityTab.vue b/app/static/src/app/components/multiSensitivity/MultiSensitivityTab.vue
new file mode 100644
index 000000000..7e9d338cb
--- /dev/null
+++ b/app/static/src/app/components/multiSensitivity/MultiSensitivityTab.vue
@@ -0,0 +1,12 @@
+<template>
+  <div class="multi-sensitivity-tab">
+    Multi-sensitivity coming soon!
+  </div>
+</template>
+<script lang="ts">
+import { defineComponent } from "vue";
+
+export default defineComponent({
+    name: "MultiSensitivityTab"
+});
+</script>
diff --git a/app/static/src/app/components/options/EditParamSettings.vue b/app/static/src/app/components/options/EditParamSettings.vue
index 5e850f189..3c5818423 100644
--- a/app/static/src/app/components/options/EditParamSettings.vue
+++ b/app/static/src/app/components/options/EditParamSettings.vue
@@ -82,7 +82,7 @@
                   <label class="col-form-label">Values</label>
                 </div>
                 <div class="col-6">
-                  <tag-input :tags="settingsInternal.customValues" :numeric-only="true" @update="updateUserValues">
+                  <tag-input :tags="settingsInternal.customValues" :numeric-only="true" @update="updateCustomValues">
                   </tag-input>
                 </div>
               </div>
@@ -123,10 +123,9 @@
 
 <script lang="ts">
 import {
-    computed, defineComponent, reactive, watch
+    computed, defineComponent, PropType, reactive, watch
 } from "vue";
 import { useStore } from "vuex";
-import { SensitivityMutation } from "../../store/sensitivity/mutations";
 import {
     SensitivityParameterSettings,
     SensitivityScaleType,
@@ -139,11 +138,15 @@ import ErrorInfo from "../ErrorInfo.vue";
 import TagInput from "./TagInput.vue";
 
 export default defineComponent({
-    name: "EditParamSettings.vue",
+    name: "EditParamSettings",
     props: {
         open: {
             type: Boolean,
             required: true
+        },
+        paramSettings: {
+            type: Object as PropType<SensitivityParameterSettings>,
+            required: false
         }
     },
     components: {
@@ -169,7 +172,7 @@ export default defineComponent({
 
         watch(() => props.open, (newValue) => {
             if (newValue) {
-                Object.assign(settingsInternal, { ...store.state.sensitivity.paramSettings });
+                Object.assign(settingsInternal, { ...props.paramSettings });
             }
         });
 
@@ -191,7 +194,7 @@ export default defineComponent({
             }
             return batchParsResult.value?.error;
         });
-        const updateUserValues = (newValues: number[]) => {
+        const updateCustomValues = (newValues: number[]) => {
             // sort and remove duplicates
             settingsInternal.customValues = newValues;
         };
@@ -200,8 +203,7 @@ export default defineComponent({
         const updateSettings = () => {
             // sort custom values
             const customValues = settingsInternal.customValues.sort((a, b) => a - b);
-            store.commit(`sensitivity/${SensitivityMutation.SetParamSettings}`,
-                { ...settingsInternal, customValues });
+            emit("update", { ...settingsInternal, customValues });
             close();
         };
 
@@ -214,7 +216,7 @@ export default defineComponent({
             centralValue,
             batchPars,
             batchParsError,
-            updateUserValues,
+            updateCustomValues,
             close,
             updateSettings
         };
diff --git a/app/static/src/app/components/options/OptionsTab.vue b/app/static/src/app/components/options/OptionsTab.vue
index 81c6410e8..e5b413d0f 100644
--- a/app/static/src/app/components/options/OptionsTab.vue
+++ b/app/static/src/app/components/options/OptionsTab.vue
@@ -1,31 +1,32 @@
 <template>
-    <div>
-        <sensitivity-options v-if="sensitivityOpen"></sensitivity-options>
-        <vertical-collapse v-if="isFit" title="Link" collapse-id="link-data">
-          <link-data></link-data>
-        </vertical-collapse>
-        <vertical-collapse title="Model Parameters" collapse-id="model-params">
-          <parameter-values></parameter-values>
-        </vertical-collapse>
-        <vertical-collapse title="Run Options" collapse-id="run-options">
-          <run-options></run-options>
-        </vertical-collapse>
-        <vertical-collapse v-if="fitTabIsOpen" title="Optimisation" collapse-id="optimisation">
-          <optimisation-options></optimisation-options>
-        </vertical-collapse>
-        <vertical-collapse title="Graph Settings" collapse-id="graph-settings">
-          <graph-settings></graph-settings>
-        </vertical-collapse>
-        <vertical-collapse v-if="!isStochastic"
-                           title="Advanced Settings"
-                           collapse-id="advanced-settings"
-                           :collapsed-default="true">
-          <advanced-settings></advanced-settings>
-        </vertical-collapse>
-        <vertical-collapse v-if="!isStochastic" title="Saved Parameter Sets" collapse-id="parameter-sets">
-          <parameter-sets></parameter-sets>
-        </vertical-collapse>
-    </div>
+  <div>
+    <sensitivity-options v-if="sensitivityOpen || multiSensitivityOpen"
+                         :multi-sensitivity="multiSensitivityOpen"></sensitivity-options>
+    <vertical-collapse v-if="isFit" title="Link" collapse-id="link-data">
+      <link-data></link-data>
+    </vertical-collapse>
+    <vertical-collapse title="Model Parameters" collapse-id="model-params">
+      <parameter-values></parameter-values>
+    </vertical-collapse>
+    <vertical-collapse title="Run Options" collapse-id="run-options">
+      <run-options></run-options>
+    </vertical-collapse>
+    <vertical-collapse v-if="fitTabIsOpen" title="Optimisation" collapse-id="optimisation">
+      <optimisation-options></optimisation-options>
+    </vertical-collapse>
+    <vertical-collapse title="Graph Settings" collapse-id="graph-settings">
+      <graph-settings></graph-settings>
+    </vertical-collapse>
+    <vertical-collapse v-if="!isStochastic"
+                       title="Advanced Settings"
+                       collapse-id="advanced-settings"
+                       :collapsed-default="true">
+      <advanced-settings></advanced-settings>
+    </vertical-collapse>
+    <vertical-collapse v-if="!isStochastic" title="Saved Parameter Sets" collapse-id="parameter-sets">
+      <parameter-sets></parameter-sets>
+    </vertical-collapse>
+  </div>
 </template>
 
 <script lang="ts">
@@ -61,12 +62,16 @@ export default {
         const isStochastic = computed(() => store.state.appType === AppType.Stochastic);
 
         const sensitivityOpen = computed(() => store.state.openVisualisationTab === VisualisationTab.Sensitivity);
+        const multiSensitivityOpen = computed(() => {
+            return store.state.openVisualisationTab === VisualisationTab.MultiSensitivity;
+        });
         const fitTabIsOpen = computed(() => store.state.openVisualisationTab === VisualisationTab.Fit);
 
         return {
             isFit,
             isStochastic,
             sensitivityOpen,
+            multiSensitivityOpen,
             fitTabIsOpen
         };
     }
diff --git a/app/static/src/app/components/options/SensitivityOptions.vue b/app/static/src/app/components/options/SensitivityOptions.vue
index 6280f272c..dac20a016 100644
--- a/app/static/src/app/components/options/SensitivityOptions.vue
+++ b/app/static/src/app/components/options/SensitivityOptions.vue
@@ -1,31 +1,51 @@
 <template>
-  <vertical-collapse title="Sensitivity Options" collapse-id="sensitivity-options">
+  <vertical-collapse :title="title" collapse-id="sensitivity-options">
     <template v-if="showOptions">
       <div class="mt-2 clearfix">
-        <button class="btn btn-primary mb-4 float-end" @click="toggleEdit(true)">Edit</button>
-        <ul>
-          <li><strong>Parameter:</strong> {{settings.parameterToVary}}</li>
-          <li><strong>Variation Type:</strong> {{ settings.variationType }}</li>
-          <li v-if="settings.variationType !== 'Custom'"><strong>Scale Type:</strong> {{ settings.scaleType }}</li>
-          <li v-if="settings.variationType === 'Percentage'">
-            <strong>Variation (%):</strong> {{ settings.variationPercentage }}
-          </li>
-          <template v-if="settings.variationType === 'Range'">
-            <li><strong>From:</strong> {{ settings.rangeFrom }}</li>
-            <li><strong>To:</strong> {{ settings.rangeTo }}</li>
-          </template>
-          <li v-if="settings.variationType === 'Custom'">
-            <strong>Values:</strong>
-            {{ settings.customValues.join(", ") }}
-          </li>
-          <li v-if="settings.variationType !== 'Custom'">
-            <strong>Number of runs:</strong> {{ settings.numberOfRuns}}
-          </li>
-        </ul>
-        <sensitivity-param-values v-if="settings.variationType !== 'Custom'"
-                                  :batch-pars="batchPars"
-                                  :param-name="settings.parameterToVary">
-        </sensitivity-param-values>
+        <div v-for="(settings, idx) in allSettings" :key="idx" class="sensitivity-options-settings">
+          <div class="mb-2">
+            <vue-feather v-if="canDeleteSettings"
+                         class="inline-icon clickable float-end delete-param-settings ms-2"
+                         type="trash-2"
+                         @click="() => deleteSettings(idx)"
+                         v-tooltip="`Remove ${settings.parameterToVary} Settings`"></vue-feather>
+            <vue-feather class="inline-icon clickable float-end edit-param-settings"
+                         type="edit"
+                         @click="() => openEdit(idx)"
+                         v-tooltip="`Edit ${settings.parameterToVary} Settings`"></vue-feather>
+          </div>
+          <ul>
+            <li><strong>Parameter:</strong> {{settings.parameterToVary}}</li>
+            <li><strong>Variation Type:</strong> {{ settings.variationType }}</li>
+            <li v-if="settings.variationType !== 'Custom'"><strong>Scale Type:</strong> {{ settings.scaleType }}</li>
+            <li v-if="settings.variationType === 'Percentage'">
+              <strong>Variation (%):</strong> {{ settings.variationPercentage }}
+            </li>
+            <template v-if="settings.variationType === 'Range'">
+              <li><strong>From:</strong> {{ settings.rangeFrom }}</li>
+              <li><strong>To:</strong> {{ settings.rangeTo }}</li>
+            </template>
+            <li v-if="settings.variationType === 'Custom'">
+              <strong>Values:</strong>
+              {{ settings.customValues.join(", ") }}
+            </li>
+            <li v-if="settings.variationType !== 'Custom'">
+              <strong>Number of runs:</strong> {{ settings.numberOfRuns}}
+            </li>
+          </ul>
+          <sensitivity-param-values v-if="settings.variationType !== 'Custom'"
+                                    :batch-pars="allBatchPars[idx]"
+                                    :param-name="settings.parameterToVary">
+          </sensitivity-param-values>
+          <hr v-if="idx < allSettings.length-1" />
+        </div>
+        <div v-if="multiSensitivity" class="text-center">
+          <button class="btn btn-outline add-param-settings"
+                  v-if="paramsWithoutSettings.length"
+                  id="add-param-settings"
+                  @click="addSettings"
+                  v-tooltip="'Add parameter settings'">Add</button>
+        </div>
       </div>
       <hr/>
       <sensitivity-plot-options></sensitivity-plot-options>
@@ -34,48 +54,138 @@
       {{compileModelMessage}}
     </div>
   </vertical-collapse>
-  <edit-param-settings :open="editOpen" @close="toggleEdit(false)"></edit-param-settings>
+  <edit-param-settings :open="editOpen"
+                       :param-settings="settingsToEdit"
+                       @close="closeEdit"
+                       @update="editSettings"></edit-param-settings>
 </template>
 
 <script lang="ts">
 import { useStore } from "vuex";
 import { computed, defineComponent, ref } from "vue";
+import VueFeather from "vue-feather";
+import { AppState } from "../../store/appState/state";
+import { defaultSensitivityParamSettings } from "../../store/sensitivity/sensitivity";
+import { MultiSensitivityGetter } from "../../store/multiSensitivity/getters";
 import userMessages from "../../userMessages";
 import VerticalCollapse from "../VerticalCollapse.vue";
 import EditParamSettings from "./EditParamSettings.vue";
 import { SensitivityGetter } from "../../store/sensitivity/getters";
 import SensitivityParamValues from "./SensitivityParamValues.vue";
 import SensitivityPlotOptions from "./SensitivityPlotOptions.vue";
+import { SensitivityParameterSettings } from "../../store/sensitivity/state";
+import { SensitivityMutation } from "../../store/sensitivity/mutations";
+import { MultiSensitivityMutation } from "../../store/multiSensitivity/mutations";
 
 export default defineComponent({
     name: "SensitivityOptions",
+    props: {
+        multiSensitivity: {
+            type: Boolean,
+            required: true
+        }
+    },
     components: {
+        VueFeather,
         SensitivityParamValues,
         SensitivityPlotOptions,
         VerticalCollapse,
         EditParamSettings
     },
-    setup() {
-        const store = useStore();
-        const settings = computed(() => store.state.sensitivity.paramSettings);
+    setup(props) {
+        const store = useStore<AppState>();
+        const addingParamSettings = ref(false);
+
+        const multiSensitivitySettings = computed(() => store.state.multiSensitivity.paramSettings);
+
+        const allSettings = computed(() => (props.multiSensitivity ? multiSensitivitySettings.value
+            : [store.state.sensitivity.paramSettings]));
 
-        const showOptions = computed(() => !!settings.value.parameterToVary);
+        const showOptions = computed(() => allSettings.value.length && !!allSettings.value[0].parameterToVary);
         const compileModelMessage = userMessages.sensitivity.compileRequiredForOptions;
         const editOpen = ref(false);
+        const editSettingsIdx = ref<number | null>(0);
+
+        const title = computed(() => (`${props.multiSensitivity ? "Multi-sensitivity" : "Sensitivity"} Options`));
+
+        const paramsWithoutSettings = computed(() => {
+            const used = multiSensitivitySettings.value.map((p) => p.parameterToVary);
+            return Object.keys(store.state.run.parameterValues!).filter((p) => !used.includes(p));
+        });
+
+        const defaultNewSettings = computed(() => {
+            const unused = paramsWithoutSettings.value;
+            return { ...defaultSensitivityParamSettings(), parameterToVary: unused[0] };
+        });
+
+        const settingsToEdit = computed(() => {
+            if (addingParamSettings.value) {
+                return defaultNewSettings.value;
+            }
+            return editSettingsIdx.value === null ? null : allSettings.value[editSettingsIdx.value];
+        });
+
+        const openEdit = (settingsIdx: number) => {
+            editSettingsIdx.value = settingsIdx;
+            editOpen.value = true;
+        };
+
+        const closeEdit = () => {
+            editSettingsIdx.value = null;
+            addingParamSettings.value = false;
+            editOpen.value = false;
+        };
+
+        const updateMultiSensitivitySettings = (newSettings: SensitivityParameterSettings[]) => {
+            store.commit(`multiSensitivity/${MultiSensitivityMutation.SetParamSettings}`, newSettings);
+        };
+        const editSettings = (settings: SensitivityParameterSettings) => {
+            if (!props.multiSensitivity) {
+                store.commit(`sensitivity/${SensitivityMutation.SetParamSettings}`, settings);
+            } else {
+                const newSettings = [...multiSensitivitySettings.value];
+                if (addingParamSettings.value) {
+                    newSettings.push(settings);
+                } else {
+                    newSettings[editSettingsIdx.value!] = settings;
+                }
+                updateMultiSensitivitySettings(newSettings);
+            }
+        };
+
+        const canDeleteSettings = computed(() => props.multiSensitivity && multiSensitivitySettings.value.length > 1);
+
+        const addSettings = () => {
+            addingParamSettings.value = true;
+            editOpen.value = true;
+        };
 
-        const toggleEdit = (value: boolean) => {
-            editOpen.value = value;
+        const deleteSettings = (idx: number) => {
+            const newSettings = [...multiSensitivitySettings.value];
+            newSettings.splice(idx, 1);
+            updateMultiSensitivitySettings(newSettings);
         };
 
-        const batchPars = computed(() => store.getters[`sensitivity/${SensitivityGetter.batchPars}`]);
+        const allBatchPars = computed(() => (props.multiSensitivity
+            ? store.getters[`multiSensitivity/${MultiSensitivityGetter.multiBatchPars}`]
+            : [store.getters[`sensitivity/${SensitivityGetter.batchPars}`]]));
 
         return {
-            settings,
+            title,
+            allSettings,
+            settingsToEdit,
+            paramsWithoutSettings,
+            canDeleteSettings,
             showOptions,
             compileModelMessage,
-            toggleEdit,
+            addingParamSettings,
+            closeEdit,
+            openEdit,
+            editSettings,
+            addSettings,
+            deleteSettings,
             editOpen,
-            batchPars
+            allBatchPars
         };
     }
 });
diff --git a/app/static/src/app/components/stochastic/StochasticApp.vue b/app/static/src/app/components/stochastic/StochasticApp.vue
index 54a67fc60..da82f5922 100644
--- a/app/static/src/app/components/stochastic/StochasticApp.vue
+++ b/app/static/src/app/components/stochastic/StochasticApp.vue
@@ -21,6 +21,9 @@
         <template v-slot:Sensitivity>
           <sensitivity-tab></sensitivity-tab>
         </template>
+        <template v-slot:Multi-sensitivity>
+          <multi-sensitivity-tab></multi-sensitivity-tab>
+        </template>
       </wodin-tabs>
     </template>
   </wodin-app>
@@ -29,6 +32,7 @@
 <script lang="ts">
 import { defineComponent } from "vue";
 import { useStore } from "vuex";
+import MultiSensitivityTab from "@/app/components/multiSensitivity/MultiSensitivityTab.vue";
 import { VisualisationTab } from "../../store/appState/state";
 import { AppStateMutation } from "../../store/appState/mutations";
 import WodinTabs from "../WodinTabs.vue";
@@ -37,12 +41,13 @@ import CodeTab from "../code/CodeTab.vue";
 import RunTab from "../run/RunTab.vue";
 import OptionsTab from "../options/OptionsTab.vue";
 import SensitivityTab from "../sensitivity/SensitivityTab.vue";
-import includeHelpTab from "../mixins/includeHelpTab";
+import includeConfiguredTabs from "../mixins/includeConfiguredTabs";
 import HelpTab from "../help/HelpTab.vue";
 
 export default defineComponent({
     name: "StochasticApp",
     components: {
+        MultiSensitivityTab,
         CodeTab,
         HelpTab,
         RunTab,
@@ -54,7 +59,7 @@ export default defineComponent({
     setup() {
         const store = useStore();
         const rightTabSelected = (tab: string) => { store.commit(AppStateMutation.SetOpenVisualisationTab, tab); };
-        const { helpTabName, rightTabNames } = includeHelpTab(store,
+        const { helpTabName, rightTabNames } = includeConfiguredTabs(store,
             [VisualisationTab.Run, VisualisationTab.Sensitivity]);
 
         return {
diff --git a/app/static/src/app/store/appState/state.ts b/app/static/src/app/store/appState/state.ts
index ff6c02b3a..584a0bcd7 100644
--- a/app/static/src/app/store/appState/state.ts
+++ b/app/static/src/app/store/appState/state.ts
@@ -6,6 +6,7 @@ import { SensitivityState } from "../sensitivity/state";
 import { VersionsState } from "../versions/state";
 import { GraphSettingsState } from "../graphSettings/state";
 import { LanguageState } from "../../../../translationPackage/store/state";
+import { MultiSensitivityState } from "../multiSensitivity/state";
 
 export enum AppType {
     Basic = "basic",
@@ -16,7 +17,8 @@ export enum AppType {
 export enum VisualisationTab {
     Run = "Run",
     Fit = "Fit",
-    Sensitivity = "Sensitivity"
+    Sensitivity = "Sensitivity",
+    MultiSensitivity = "Multi-sensitivity"
 }
 
 export interface AppState {
@@ -34,6 +36,7 @@ export interface AppState {
     model: ModelState
     run: RunState
     sensitivity: SensitivityState,
+    multiSensitivity: MultiSensitivityState,
     graphSettings: GraphSettingsState,
     versions: VersionsState,
     configured: boolean, // true if configuration has been loaded or rehydrated and defaults set
diff --git a/app/static/src/app/store/basic/basic.ts b/app/static/src/app/store/basic/basic.ts
index d826d1ff5..08c1ef804 100644
--- a/app/static/src/app/store/basic/basic.ts
+++ b/app/static/src/app/store/basic/basic.ts
@@ -15,6 +15,7 @@ import { versions } from "../versions/versions";
 import { graphSettings } from "../graphSettings/graphSettings";
 import { getters } from "../appState/getters";
 import { getStoreModule } from "../../../../translationPackage";
+import { multiSensitivity } from "../multiSensitivity/multiSensitivity";
 
 const language = getStoreModule();
 
@@ -46,6 +47,7 @@ export const storeOptions: StoreOptions<BasicState> = {
         run,
         code,
         sensitivity,
+        multiSensitivity,
         sessions,
         versions,
         graphSettings,
diff --git a/app/static/src/app/store/fit/fit.ts b/app/static/src/app/store/fit/fit.ts
index db56b3167..178767cbc 100644
--- a/app/static/src/app/store/fit/fit.ts
+++ b/app/static/src/app/store/fit/fit.ts
@@ -17,6 +17,7 @@ import { versions } from "../versions/versions";
 import { graphSettings } from "../graphSettings/graphSettings";
 import { getters } from "../appState/getters";
 import { getStoreModule } from "../../../../translationPackage";
+import { multiSensitivity } from "../multiSensitivity/multiSensitivity";
 
 const language = getStoreModule();
 
@@ -50,6 +51,7 @@ export const storeOptions: StoreOptions<FitState> = {
         fitData,
         modelFit,
         sensitivity,
+        multiSensitivity,
         sessions,
         versions,
         graphSettings,
diff --git a/app/static/src/app/store/model/actions.ts b/app/static/src/app/store/model/actions.ts
index 0992fba4d..8b71850df 100644
--- a/app/static/src/app/store/model/actions.ts
+++ b/app/static/src/app/store/model/actions.ts
@@ -15,6 +15,8 @@ import { RunMutation } from "../run/mutations";
 import { ModelFitMutation } from "../modelFit/mutations";
 import { ErrorsMutation } from "../errors/mutations";
 import { SensitivityMutation } from "../sensitivity/mutations";
+import { defaultSensitivityParamSettings } from "../sensitivity/sensitivity";
+import { MultiSensitivityMutation } from "../multiSensitivity/mutations";
 
 export enum ModelAction {
     FetchOdinRunner = "FetchOdinRunner",
@@ -83,10 +85,19 @@ const compileModelAndUpdateStore = (context: ActionContext<ModelState, AppState>
         // set or update selected sensitivity variable
         const { paramSettings } = rootState.sensitivity;
         const paramNames = Object.keys(newValues);
+        const newParamToVary = paramNames.length ? parameters[0].name : null;
         if (!paramSettings.parameterToVary || !paramNames.includes(paramSettings.parameterToVary)) {
-            const newParamToVary = paramNames.length ? parameters[0].name : null;
             commit(`sensitivity/${SensitivityMutation.SetParameterToVary}`, newParamToVary, { root: true });
         }
+        if (rootState.config?.multiSensitivity) {
+            // multi-sensitivity: remove any param settings without valid param, include placeholder if all removed
+            const newMultiSettings = rootState.multiSensitivity.paramSettings
+                .filter((p) => p.parameterToVary && paramNames.includes(p.parameterToVary));
+            if (!newMultiSettings.length) {
+                newMultiSettings.push({ ...defaultSensitivityParamSettings(), parameterToVary: newParamToVary });
+            }
+            commit(`multiSensitivity/${MultiSensitivityMutation.SetParamSettings}`, newMultiSettings, { root: true });
+        }
 
         if (rootState.appType === AppType.Fit) {
             commit(`modelFit/${ModelFitMutation.SetFitUpdateRequired}`, { modelChanged: true }, { root: true });
diff --git a/app/static/src/app/store/multiSensitivity/getters.ts b/app/static/src/app/store/multiSensitivity/getters.ts
new file mode 100644
index 000000000..863d4eaa2
--- /dev/null
+++ b/app/static/src/app/store/multiSensitivity/getters.ts
@@ -0,0 +1,21 @@
+import { Getter, GetterTree } from "vuex";
+import { MultiSensitivityState } from "./state";
+import { AppState } from "../appState/state";
+import { generateBatchPars } from "../../utils";
+
+export enum MultiSensitivityGetter {
+    multiBatchPars = "multiBatchPars"
+}
+
+export interface MultiSensitivityGetters {
+    [MultiSensitivityGetter.multiBatchPars]: Getter<MultiSensitivityState, AppState>
+}
+
+export const getters: MultiSensitivityGetters & GetterTree<MultiSensitivityState, AppState> = {
+    [MultiSensitivityGetter.multiBatchPars]: (state: MultiSensitivityState, _: MultiSensitivityGetters,
+        rootState: AppState) => {
+        return state.paramSettings.map((settings) => {
+            return generateBatchPars(rootState, settings, rootState.run.parameterValues).batchPars;
+        });
+    }
+};
diff --git a/app/static/src/app/store/multiSensitivity/multiSensitivity.ts b/app/static/src/app/store/multiSensitivity/multiSensitivity.ts
new file mode 100644
index 000000000..2eeba57ca
--- /dev/null
+++ b/app/static/src/app/store/multiSensitivity/multiSensitivity.ts
@@ -0,0 +1,21 @@
+import { MultiSensitivityState } from "./state";
+import { noSensitivityUpdateRequired } from "../sensitivity/sensitivity";
+import { mutations } from "./mutations";
+import { getters } from "./getters";
+
+export const defaultState: MultiSensitivityState = {
+    result: null,
+    downloading: false,
+    userSummaryDownloadFileName: "",
+    sensitivityUpdateRequired: noSensitivityUpdateRequired(),
+    running: false,
+    loading: false,
+    paramSettings: []
+};
+
+export const multiSensitivity = {
+    namespaced: true,
+    state: defaultState,
+    mutations,
+    getters
+};
diff --git a/app/static/src/app/store/multiSensitivity/mutations.ts b/app/static/src/app/store/multiSensitivity/mutations.ts
new file mode 100644
index 000000000..0b4d7fe96
--- /dev/null
+++ b/app/static/src/app/store/multiSensitivity/mutations.ts
@@ -0,0 +1,13 @@
+import { MutationTree } from "vuex";
+import { MultiSensitivityState } from "./state";
+import { SensitivityParameterSettings } from "../sensitivity/state";
+
+export enum MultiSensitivityMutation {
+    SetParamSettings = "SetParamSettings"
+}
+
+export const mutations: MutationTree<MultiSensitivityState> = {
+    [MultiSensitivityMutation.SetParamSettings](state:MultiSensitivityState, payload: SensitivityParameterSettings[]) {
+        state.paramSettings = payload;
+    }
+};
diff --git a/app/static/src/app/store/multiSensitivity/state.ts b/app/static/src/app/store/multiSensitivity/state.ts
new file mode 100644
index 000000000..b6f1f473b
--- /dev/null
+++ b/app/static/src/app/store/multiSensitivity/state.ts
@@ -0,0 +1,5 @@
+import { BaseSensitivityState, SensitivityParameterSettings } from "../sensitivity/state";
+
+export interface MultiSensitivityState extends BaseSensitivityState{
+    paramSettings: SensitivityParameterSettings[]
+}
diff --git a/app/static/src/app/store/sensitivity/sensitivity.ts b/app/static/src/app/store/sensitivity/sensitivity.ts
index 5adb5852c..1723c4bf6 100644
--- a/app/static/src/app/store/sensitivity/sensitivity.ts
+++ b/app/static/src/app/store/sensitivity/sensitivity.ts
@@ -9,29 +9,33 @@ import { mutations } from "./mutations";
 import { actions } from "./actions";
 import { getters } from "./getters";
 
+export const defaultSensitivityParamSettings = () => ({
+    parameterToVary: null,
+    scaleType: SensitivityScaleType.Arithmetic,
+    variationType: SensitivityVariationType.Percentage,
+    variationPercentage: 10,
+    rangeFrom: 0,
+    rangeTo: 0,
+    numberOfRuns: 10,
+    customValues: []
+});
+
+export const noSensitivityUpdateRequired = () => ({
+    modelChanged: false,
+    parameterValueChanged: false,
+    endTimeChanged: false,
+    sensitivityOptionsChanged: false,
+    numberOfReplicatesChanged: false
+});
+
 export const defaultState: SensitivityState = {
-    paramSettings: {
-        parameterToVary: null,
-        scaleType: SensitivityScaleType.Arithmetic,
-        variationType: SensitivityVariationType.Percentage,
-        variationPercentage: 10,
-        rangeFrom: 0,
-        rangeTo: 0,
-        numberOfRuns: 10,
-        customValues: []
-    },
+    paramSettings: defaultSensitivityParamSettings(),
     plotSettings: {
         plotType: SensitivityPlotType.TraceOverTime,
         extreme: SensitivityPlotExtreme.Max,
         time: null
     },
-    sensitivityUpdateRequired: {
-        modelChanged: false,
-        parameterValueChanged: false,
-        endTimeChanged: false,
-        sensitivityOptionsChanged: false,
-        numberOfReplicatesChanged: false
-    },
+    sensitivityUpdateRequired: noSensitivityUpdateRequired(),
     result: null,
     parameterSetResults: {},
     downloading: false,
diff --git a/app/static/src/app/store/sensitivity/state.ts b/app/static/src/app/store/sensitivity/state.ts
index 0c0fd224c..29f980780 100644
--- a/app/static/src/app/store/sensitivity/state.ts
+++ b/app/static/src/app/store/sensitivity/state.ts
@@ -54,16 +54,12 @@ export interface SensitivityUpdateRequiredReasons {
     numberOfReplicatesChanged: boolean;
 }
 
-export interface SensitivityState {
-    paramSettings: SensitivityParameterSettings,
-    // Whether sensitivity needs to be re-run because of change to settings or model
-    sensitivityUpdateRequired: SensitivityUpdateRequiredReasons
-    plotSettings: SensitivityPlotSettings,
+export interface BaseSensitivityState {
     result: OdinSensitivityResult | null;
-    parameterSetResults: Dict<OdinSensitivityResult>,
     downloading: boolean,
     userSummaryDownloadFileName: string,
-
+    // Whether sensitivity needs to be re-run because of change to settings or model
+    sensitivityUpdateRequired: SensitivityUpdateRequiredReasons
     // true only in stochastic mode when odinWorker produces multiple sensitivity
     // traces sequentially. This toggle is required to show how many runs out of
     // the total have finished.  Turned off when all runs are complete
@@ -73,3 +69,9 @@ export interface SensitivityState {
     // reshaping the data
     loading: boolean
 }
+
+export interface SensitivityState extends BaseSensitivityState {
+    paramSettings: SensitivityParameterSettings,
+    plotSettings: SensitivityPlotSettings,
+    parameterSetResults: Dict<OdinSensitivityResult>,
+}
diff --git a/app/static/src/app/store/stochastic/stochastic.ts b/app/static/src/app/store/stochastic/stochastic.ts
index c0b12f4c0..56c5dddb2 100644
--- a/app/static/src/app/store/stochastic/stochastic.ts
+++ b/app/static/src/app/store/stochastic/stochastic.ts
@@ -15,6 +15,7 @@ import { versions } from "../versions/versions";
 import { graphSettings } from "../graphSettings/graphSettings";
 import { getters } from "../appState/getters";
 import { getStoreModule } from "../../../../translationPackage";
+import { multiSensitivity } from "../multiSensitivity/multiSensitivity";
 
 const language = getStoreModule();
 
@@ -46,6 +47,7 @@ export const storeOptions: StoreOptions<StochasticState> = {
         model,
         run,
         sensitivity,
+        multiSensitivity,
         sessions,
         versions,
         graphSettings,
diff --git a/app/static/src/app/types/responseTypes.ts b/app/static/src/app/types/responseTypes.ts
index 6c832ac8c..767973f15 100644
--- a/app/static/src/app/types/responseTypes.ts
+++ b/app/static/src/app/types/responseTypes.ts
@@ -25,7 +25,8 @@ export interface AppConfigBase {
     help?: {
         markdown?: string[],
         tabName?: string
-    }
+    },
+    multiSensitivity?: boolean
 }
 
 export interface BasicConfig extends AppConfigBase {
diff --git a/app/static/tests/e2e/multiSensitivity.etest.ts b/app/static/tests/e2e/multiSensitivity.etest.ts
new file mode 100644
index 000000000..d31f0ea25
--- /dev/null
+++ b/app/static/tests/e2e/multiSensitivity.etest.ts
@@ -0,0 +1,120 @@
+import { expect, Page, test } from "@playwright/test";
+import { SensitivityScaleType, SensitivityVariationType } from "../../src/app/store/sensitivity/state";
+
+test.describe("Multi-sensitivity tests", () => {
+    test.beforeEach(async ({ page }) => {
+        await page.goto("/apps/day1");
+        // Open Options tab
+        await page.click(":nth-match(.wodin-left .nav-tabs a, 2)");
+        // Open Multi-sensitivity tab
+        await page.click(":nth-match(.wodin-right .nav-tabs a, 3)");
+    });
+
+    const expectOptionsTabParamSettings = async (page: Page, index: number, param: string, scale: SensitivityScaleType,
+        variation: SensitivityVariationType, percentage: number | null, from: number | null, to: number | null,
+        runs: number, values: string) => {
+        const section = await page.locator(`:nth-match(.sensitivity-options-settings, ${index})`);
+        const listItems = await section.locator("ul li");
+        await expect(await listItems.nth(0).innerText()).toBe(`Parameter: ${param}`);
+        await expect(await listItems.nth(1).innerText()).toBe(`Variation Type: ${variation}`);
+        await expect(await listItems.nth(2).innerText()).toBe(`Scale Type: ${scale}`);
+        if (variation === SensitivityVariationType.Percentage) {
+            await expect(await listItems.nth(3).innerText()).toBe(`Variation (%): ${percentage}`);
+            await expect(await listItems.nth(4).innerText()).toBe(`Number of runs: ${runs}`);
+        } else {
+            await expect(await listItems.nth(3).innerText()).toBe(`From: ${from}`);
+            await expect(await listItems.nth(4).innerText()).toBe(`To: ${to}`);
+            await expect(await listItems.nth(5).innerText()).toBe(`Number of runs: ${runs}`);
+        }
+
+        await expect(await section.locator(".alert-success").innerText()).toBe(` ${values}`);
+    };
+
+    const expectModalParamSettings = async (page: Page, param: string, scale: SensitivityScaleType,
+        variation: SensitivityVariationType, percentage: number | null, from: number | null, central: number | null,
+        to: number | null, runs: number, values: string) => {
+        await expect(await page.inputValue("#edit-param-to-vary select")).toBe(param);
+        await expect(await page.inputValue("#edit-variation-type select")).toBe(variation);
+        await expect(await page.inputValue("#edit-scale-type select")).toBe(scale);
+        if (variation === SensitivityVariationType.Percentage) {
+            await expect(await page.inputValue("#edit-percent input")).toBe(percentage!.toString());
+        } else {
+            await expect(await page.inputValue("#edit-from input")).toBe(from!.toString());
+            await expect(await page.innerText("#param-central-value")).toBe(central!.toString());
+            await expect(await page.inputValue("#edit-to input")).toBe(to!.toString());
+        }
+
+        await expect(await page.inputValue("#edit-runs input")).toBe(runs.toString());
+        await expect(await page.innerText("#edit-param .alert-success")).toBe(` ${values}`);
+    };
+
+    test("can edit Multi-sensitivity options", async ({ page }) => {
+        // check default param settings
+        await expect(await page.locator(".sensitivity-options-settings").count()).toBe(1);
+        await expectOptionsTabParamSettings(page, 1, "beta", SensitivityScaleType.Arithmetic,
+            SensitivityVariationType.Percentage, 10, null, null, 10, "3.600, 3.689, 3.778, ..., 4.400");
+
+        // should be no delete button on first param settings
+        await expect(await page.locator(".delete-param-to-vary").count()).toBe(0);
+
+        // open edit param settings dialog and check values
+        await page.click(":nth-match(.edit-param-settings, 1)");
+        await expect(await page.locator("#edit-param").count()).toBe(1);
+        await expectModalParamSettings(page, "beta", SensitivityScaleType.Arithmetic,
+            SensitivityVariationType.Percentage, 10, null, null, null, 10, "3.600, 3.689, 3.778, ..., 4.400");
+
+        // edit default params settings
+        await page.selectOption("#edit-variation-type select", "Range");
+        await expect(await page.isDisabled("#ok-settings")).toBe(true); // default range is invalid
+        await page.fill("#edit-to input", "9");
+        await expect(await page.isEnabled("#ok-settings")).toBe(true);
+        await page.click("#ok-settings");
+
+        // checked edited settings saved correctly
+        await expectOptionsTabParamSettings(page, 1, "beta", SensitivityScaleType.Arithmetic,
+            SensitivityVariationType.Range, null, 0, 9, 10, "0.000, 1.000, 2.000, ..., 9.000");
+
+        // Add new settings - save defaults
+        await page.click("#add-param-settings");
+        await expectModalParamSettings(page, "I0", SensitivityScaleType.Arithmetic,
+            SensitivityVariationType.Percentage, 10, null, null, null, 10, "0.900, 0.922, 0.944, ..., 1.100");
+        await page.click("#ok-settings");
+        await expect(await page.locator(".sensitivity-options-settings").count()).toBe(2);
+        await expectOptionsTabParamSettings(page, 2, "I0", SensitivityScaleType.Arithmetic,
+            SensitivityVariationType.Percentage, 10, null, null, 10, "0.900, 0.922, 0.944, ..., 1.100");
+
+        // Add another new settings - make changes before saving
+        await page.click("#add-param-settings");
+        await expectModalParamSettings(page, "N", SensitivityScaleType.Arithmetic,
+            SensitivityVariationType.Percentage, 10, null, null, null, 10,
+            "900000.000, 922222.222, 944444.444, ..., 1100000.000");
+
+        // change a parameter
+        await page.selectOption("#edit-param-to-vary select", "sigma");
+        await expectModalParamSettings(page, "sigma", SensitivityScaleType.Arithmetic,
+            SensitivityVariationType.Percentage, 10, null, null, null, 10, "1.800, 1.844, 1.889, ..., 2.200");
+        // change percent
+        await page.fill("#edit-percent input", "5");
+        await expectModalParamSettings(page, "sigma", SensitivityScaleType.Arithmetic,
+            SensitivityVariationType.Percentage, 5, null, null, null, 10, "1.900, 1.922, 1.944, ..., 2.100");
+
+        // Save
+        await page.click("#ok-settings");
+        await expect(await page.locator(".sensitivity-options-settings").count()).toBe(3);
+        await expectOptionsTabParamSettings(page, 1, "beta", SensitivityScaleType.Arithmetic,
+            SensitivityVariationType.Range, null, 0, 9, 10, "0.000, 1.000, 2.000, ..., 9.000");
+        await expectOptionsTabParamSettings(page, 2, "I0", SensitivityScaleType.Arithmetic,
+            SensitivityVariationType.Percentage, 10, null, null, 10, "0.900, 0.922, 0.944, ..., 1.100");
+        await expectOptionsTabParamSettings(page, 3, "sigma", SensitivityScaleType.Arithmetic,
+            SensitivityVariationType.Percentage, 5, null, null, 10, "1.900, 1.922, 1.944, ..., 2.100");
+
+        // Delete one settings
+        await page.click(":nth-match(.delete-param-settings, 2)");
+
+        await expect(await page.locator(".sensitivity-options-settings").count()).toBe(2);
+        await expectOptionsTabParamSettings(page, 1, "beta", SensitivityScaleType.Arithmetic,
+            SensitivityVariationType.Range, null, 0, 9, 10, "0.000, 1.000, 2.000, ..., 9.000");
+        await expectOptionsTabParamSettings(page, 2, "sigma", SensitivityScaleType.Arithmetic,
+            SensitivityVariationType.Percentage, 5, null, null, 10, "1.900, 1.922, 1.944, ..., 2.100");
+    });
+});
diff --git a/app/static/tests/e2e/sensitivity.etest.ts b/app/static/tests/e2e/sensitivity.etest.ts
index 1c5ae7813..78b6e430a 100644
--- a/app/static/tests/e2e/sensitivity.etest.ts
+++ b/app/static/tests/e2e/sensitivity.etest.ts
@@ -25,7 +25,7 @@ test.describe("Sensitivity tests", () => {
 
         // Edit settings
         await expect(await page.isVisible(".modal")).toBe(false);
-        await page.click("#sensitivity-options .btn-primary");
+        await page.click("#sensitivity-options .edit-param-settings");
         await expect(await page.locator("#edit-param .modal")).toBeVisible();
         await expect(await page.innerText("#edit-param .modal-title")).toBe("Vary Parameter");
         await expect(await page.locator("#invalid-msg").count()).toBe(0);
@@ -231,7 +231,7 @@ test.describe("Sensitivity tests", () => {
     });
 
     test("can change sensitivity settings to Custom variation, and see values in plot", async ({ page }) => {
-        await page.click("#sensitivity-options .btn-primary");
+        await page.click("#sensitivity-options .edit-param-settings");
         await expect(await page.locator("#edit-param .modal")).toBeVisible();
         const varSelect = await page.locator("#edit-variation-type select");
         await varSelect.selectOption("Custom");
diff --git a/app/static/tests/mocks.ts b/app/static/tests/mocks.ts
index a841935ea..87e593add 100644
--- a/app/static/tests/mocks.ts
+++ b/app/static/tests/mocks.ts
@@ -24,6 +24,8 @@ import { VersionsState } from "../src/app/store/versions/state";
 import { GraphSettingsState } from "../src/app/store/graphSettings/state";
 import { LanguageState } from "../translationPackage/store/state";
 import { Language } from "../src/app/types/languageTypes";
+import { noSensitivityUpdateRequired } from "../src/app/store/sensitivity/sensitivity";
+import { MultiSensitivityState } from "../src/app/store/multiSensitivity/state";
 
 export const mockAxios = new MockAdapter(axios);
 
@@ -165,19 +167,26 @@ export const mockSensitivityState = (state: Partial<SensitivityState> = {}): Sen
             extreme: SensitivityPlotExtreme.Max,
             time: null
         },
-        sensitivityUpdateRequired: {
-            modelChanged: false,
-            parameterValueChanged: false,
-            endTimeChanged: false,
-            sensitivityOptionsChanged: false,
-            numberOfReplicatesChanged: false
-        },
+        sensitivityUpdateRequired: noSensitivityUpdateRequired(),
         result: null,
         parameterSetResults: {},
         ...state
     };
 };
 
+export const mockMultiSensitivityState = (state: Partial<MultiSensitivityState> = {}): MultiSensitivityState => {
+    return {
+        result: null,
+        downloading: false,
+        userSummaryDownloadFileName: "",
+        sensitivityUpdateRequired: noSensitivityUpdateRequired(),
+        running: false,
+        loading: false,
+        paramSettings: [],
+        ...state
+    };
+};
+
 export const mockBasicState = (state: Partial<BasicState> = {}): BasicState => {
     return {
         sessionId: "123",
@@ -198,6 +207,7 @@ export const mockBasicState = (state: Partial<BasicState> = {}): BasicState => {
         model: mockModelState(),
         run: mockRunState(),
         sensitivity: mockSensitivityState(),
+        multiSensitivity: mockMultiSensitivityState(),
         versions: mockVersionsState(),
         graphSettings: mockGraphSettingsState(),
         configured: false,
@@ -246,6 +256,7 @@ export const mockFitState = (state: Partial<FitState> = {}): FitState => {
         run: mockRunState(),
         fitData: mockFitDataState(),
         sensitivity: mockSensitivityState(),
+        multiSensitivity: mockMultiSensitivityState(),
         modelFit: mockModelFitState(),
         versions: mockVersionsState(),
         graphSettings: mockGraphSettingsState(),
@@ -276,6 +287,7 @@ export const mockStochasticState = (state: Partial<StochasticState> = {}): Stoch
         model: mockModelState(),
         run: mockRunState(),
         sensitivity: mockSensitivityState(),
+        multiSensitivity: mockMultiSensitivityState(),
         versions: mockVersionsState(),
         graphSettings: mockGraphSettingsState(),
         configured: false,
diff --git a/app/static/tests/testUtils.ts b/app/static/tests/testUtils.ts
index ff5a5a485..c28a0479c 100644
--- a/app/static/tests/testUtils.ts
+++ b/app/static/tests/testUtils.ts
@@ -1,3 +1,6 @@
+import { VueWrapper } from "@vue/test-utils";
+import WodinPanels from "../src/app/components/WodinPanels.vue";
+
 export const fileTimeout = 20;
 
 export const expectCloseNumericArray = (actual: number[], expected: number[]) => {
@@ -6,3 +9,23 @@ export const expectCloseNumericArray = (actual: number[], expected: number[]) =>
         expect(value).toBeCloseTo(expected[idx]);
     });
 };
+
+const expectWodinTabs = (wrapper: VueWrapper<any>, expectedTabNames: string[], tabType: string) => {
+    const wodinPanels = wrapper.findComponent(WodinPanels);
+    const panel = wodinPanels.find(`.wodin-${tabType}`);
+    const tabs = panel.find(`#${tabType}-tabs`);
+    const links = tabs.findAll("ul li a");
+
+    expect(links.length).toBe(expectedTabNames.length);
+    expectedTabNames.forEach((expected: string, idx: number) => {
+        expect(links[idx]!.text()).toBe(expected);
+    });
+};
+
+export const expectRightWodinTabs = (wrapper: VueWrapper<any>, expectedTabNames: string[]) => {
+    expectWodinTabs(wrapper, expectedTabNames, "right");
+};
+
+export const expectLeftWodinTabs = (wrapper: VueWrapper<any>, expectedTabNames: string[]) => {
+    expectWodinTabs(wrapper, expectedTabNames, "left");
+};
diff --git a/app/static/tests/unit/components/basic/basicApp.test.ts b/app/static/tests/unit/components/basic/basicApp.test.ts
index 941936ba1..41be2a80f 100644
--- a/app/static/tests/unit/components/basic/basicApp.test.ts
+++ b/app/static/tests/unit/components/basic/basicApp.test.ts
@@ -14,6 +14,7 @@ jest.mock("../../../../src/app/components/help/MarkdownItImport.ts", () => {
 /* eslint-disable import/first */
 import Vuex from "vuex";
 import { mount } from "@vue/test-utils";
+import { expectLeftWodinTabs, expectRightWodinTabs } from "../../../testUtils";
 import HelpTab from "../../../../src/app/components/help/HelpTab.vue";
 import BasicApp from "../../../../src/app/components/basic/BasicApp.vue";
 import { BasicState } from "../../../../src/app/store/basic/state";
@@ -23,6 +24,7 @@ import {
 import WodinApp from "../../../../src/app/components/WodinApp.vue";
 import WodinPanels from "../../../../src/app/components/WodinPanels.vue";
 import OptionsTab from "../../../../src/app/components/options/OptionsTab.vue";
+import MultiSensitivityTab from "../../../../src/app/components/multiSensitivity/MultiSensitivityTab.vue";
 import { ModelAction } from "../../../../src/app/store/model/actions";
 import { AppStateAction } from "../../../../src/app/store/appState/actions";
 import { VisualisationTab } from "../../../../src/app/store/appState/state";
@@ -92,20 +94,14 @@ describe("BasicApp", () => {
         const wodinApp = wrapper.findComponent(WodinApp);
 
         const wodinPanels = wodinApp.findComponent(WodinPanels);
-        const leftPanel = wodinPanels.find(".wodin-left");
-        const leftTabs = leftPanel.find("#left-tabs");
-        const leftTabLinks = leftTabs.findAll("ul li a");
-        expect(leftTabLinks.length).toBe(2);
-        expect(leftTabLinks.at(0)!.text()).toBe("Code");
-        expect(leftTabLinks.at(1)!.text()).toBe("Options");
+
+        expectLeftWodinTabs(wrapper, ["Code", "Options"]);
+        const leftTabs = wodinPanels.find(".wodin-left #left-tabs");
         expect(leftTabs.find("div.mt-4 div.code-tab").exists()).toBe(true);
 
-        const rightPanel = wodinPanels.find(".wodin-right");
-        const rightTabs = rightPanel.find("#right-tabs");
+        expectRightWodinTabs(wrapper, ["Run", "Sensitivity"]);
+        const rightTabs = wodinPanels.find(".wodin-right #right-tabs");
         const rightTabLinks = rightTabs.findAll("ul li a");
-        expect(rightTabLinks.length).toBe(2);
-        expect(rightTabLinks.at(0)!.text()).toBe("Run");
-        expect(rightTabLinks.at(1)!.text()).toBe("Sensitivity");
         expect(rightTabs.find("div.mt-4 div.run-tab").exists()).toBe(true);
     });
 
@@ -145,14 +141,35 @@ describe("BasicApp", () => {
             }
         };
         const wrapper = getWrapper(jest.fn(), helpConfig);
-        const wodinPanels = wrapper.findComponent(WodinPanels);
-        const rightPanel = wodinPanels.find(".wodin-right");
-        const rightTabs = rightPanel.find("#right-tabs");
-        const rightTabLinks = rightTabs.findAll("ul li a");
-        expect(rightTabLinks.length).toBe(3);
-        expect(rightTabLinks.at(0)!.text()).toBe("Help");
-        expect(rightTabLinks.at(1)!.text()).toBe("Run");
-        expect(rightTabLinks.at(2)!.text()).toBe("Sensitivity");
+        expectRightWodinTabs(wrapper, ["Help", "Run", "Sensitivity"]);
+
+        const rightTabs = wrapper.findComponent(WodinPanels).find(".wodin-right #right-tabs");
         expect(rightTabs.findComponent(HelpTab).exists()).toBe(true);
     });
+
+    it("renders Multi-sensitivity tab if configured", async () => {
+        const multiSensConfig = {
+            multiSensitivity: true
+        };
+        const wrapper = getWrapper(jest.fn(), multiSensConfig);
+        expectRightWodinTabs(wrapper, ["Run", "Sensitivity", "Multi-sensitivity"]);
+
+        const rightTabs = wrapper.findComponent(WodinPanels).find(".wodin-right #right-tabs");
+        const rightTabLinks = rightTabs.findAll("ul li a");
+        // Change to Options tab
+        await rightTabLinks.at(2)!.trigger("click");
+        expect(rightTabs.findComponent(MultiSensitivityTab).exists()).toBe(true);
+    });
+
+    it("renders both Help and MultiSensitivity if configured", () => {
+        const bothConfig = {
+            help: {
+                markdown: ["test md"],
+                tabName: "Help"
+            },
+            multiSensitivity: true
+        };
+        const wrapper = getWrapper(jest.fn(), bothConfig);
+        expectRightWodinTabs(wrapper, ["Help", "Run", "Sensitivity", "Multi-sensitivity"]);
+    });
 });
diff --git a/app/static/tests/unit/components/fit/fitApp.test.ts b/app/static/tests/unit/components/fit/fitApp.test.ts
index 7791edc49..3b6124303 100644
--- a/app/static/tests/unit/components/fit/fitApp.test.ts
+++ b/app/static/tests/unit/components/fit/fitApp.test.ts
@@ -15,6 +15,7 @@ jest.mock("../../../../src/app/components/help/MarkdownItImport.ts", () => {
 /* eslint-disable import/first */
 import Vuex from "vuex";
 import { mount } from "@vue/test-utils";
+import { expectLeftWodinTabs, expectRightWodinTabs } from "../../../testUtils";
 import FitApp from "../../../../src/app/components/fit/FitApp.vue";
 import { FitState } from "../../../../src/app/store/fit/state";
 import { AppStateAction } from "../../../../src/app/store/appState/actions";
@@ -29,6 +30,7 @@ import CodeTab from "../../../../src/app/components/code/CodeTab.vue";
 import DataTab from "../../../../src/app/components/data/DataTab.vue";
 import RunTab from "../../../../src/app/components/run/RunTab.vue";
 import HelpTab from "../../../../src/app/components/help/HelpTab.vue";
+import MultiSensitivityTab from "../../../../src/app/components/multiSensitivity/MultiSensitivityTab.vue";
 import { VisualisationTab } from "../../../../src/app/store/appState/state";
 import { AppStateMutation } from "../../../../src/app/store/appState/mutations";
 import { ModelFitGetter } from "../../../../src/app/store/modelFit/getters";
@@ -104,22 +106,13 @@ describe("FitApp", () => {
         const wodinApp = wrapper.findComponent(WodinApp);
 
         const wodinPanels = wodinApp.findComponent(WodinPanels);
-        const leftPanel = wodinPanels.find(".wodin-left");
-        const leftTabs = leftPanel.find("#left-tabs");
-        const leftTabLinks = leftTabs.findAll("ul li a");
-        expect(leftTabLinks.length).toBe(3);
-        expect(leftTabLinks.at(0)!.text()).toBe("Data");
-        expect(leftTabLinks.at(1)!.text()).toBe("Code");
-        expect(leftTabLinks.at(2)!.text()).toBe("Options");
+        expectLeftWodinTabs(wrapper, ["Data", "Code", "Options"]);
+
+        const leftTabs = wodinPanels.find(".wodin-left #left-tabs");
         expect(leftTabs.findComponent(DataTab).exists()).toBe(true);
 
-        const rightPanel = wodinPanels.find(".wodin-right");
-        const rightTabs = rightPanel.find("#right-tabs");
-        const rightTabLinks = rightTabs.findAll("ul li a");
-        expect(rightTabLinks.length).toBe(3);
-        expect(rightTabLinks.at(0)!.text()).toBe("Run");
-        expect(rightTabLinks.at(1)!.text()).toBe("Fit");
-        expect(rightTabLinks.at(2)!.text()).toBe("Sensitivity");
+        expectRightWodinTabs(wrapper, ["Run", "Fit", "Sensitivity"]);
+        const rightTabs = wodinPanels.find(".wodin-right #right-tabs");
         expect(rightTabs.findComponent(RunTab).exists()).toBe(true);
     });
 
@@ -182,13 +175,36 @@ describe("FitApp", () => {
         const wrapper = getWrapper(jest.fn(), helpConfig);
         const wodinPanels = wrapper.findComponent(WodinPanels);
         const rightPanel = wodinPanels.find(".wodin-right");
-        const rightTabs = rightPanel.find("#right-tabs");
-        const rightTabLinks = rightTabs.findAll("ul li a");
-        expect(rightTabLinks.length).toBe(4);
-        expect(rightTabLinks.at(0)!.text()).toBe("Help");
-        expect(rightTabLinks.at(1)!.text()).toBe("Run");
-        expect(rightTabLinks.at(2)!.text()).toBe("Fit");
-        expect(rightTabLinks.at(3)!.text()).toBe("Sensitivity");
+
+        expectRightWodinTabs(wrapper, ["Help", "Run", "Fit", "Sensitivity"]);
+        const rightTabs = wodinPanels.find(".wodin-right #right-tabs");
         expect(rightTabs.findComponent(HelpTab).exists()).toBe(true);
     });
+
+    it("renders Multi-sensitivity tab if configured", async () => {
+        const multiSensConfig = {
+            multiSensitivity: true
+        };
+        const wrapper = getWrapper(jest.fn(), multiSensConfig);
+        const wodinPanels = wrapper.findComponent(WodinPanels);
+
+        expectRightWodinTabs(wrapper, ["Run", "Fit", "Sensitivity", "Multi-sensitivity"]);
+        // Change to Options tab
+        const rightTabs = wodinPanels.find(".wodin-right #right-tabs");
+        const rightTabLinks = rightTabs.findAll("ul li a");
+        await rightTabLinks.at(3)!.trigger("click");
+        expect(rightTabs.findComponent(MultiSensitivityTab).exists()).toBe(true);
+    });
+
+    it("renders both Help and MultiSensitivity if configured", () => {
+        const bothConfig = {
+            help: {
+                markdown: ["test md"],
+                tabName: "Help"
+            },
+            multiSensitivity: true
+        };
+        const wrapper = getWrapper(jest.fn(), bothConfig);
+        expectRightWodinTabs(wrapper, ["Help", "Run", "Fit", "Sensitivity", "Multi-sensitivity"]);
+    });
 });
diff --git a/app/static/tests/unit/components/mixins/includeConfiguredTabs.test.ts b/app/static/tests/unit/components/mixins/includeConfiguredTabs.test.ts
new file mode 100644
index 000000000..5295d36b6
--- /dev/null
+++ b/app/static/tests/unit/components/mixins/includeConfiguredTabs.test.ts
@@ -0,0 +1,70 @@
+import Vuex from "vuex";
+import { BasicState } from "../../../../src/app/store/basic/state";
+import { mockBasicState } from "../../../mocks";
+import includeConfiguredTabs from "../../../../src/app/components/mixins/includeConfiguredTabs";
+
+describe("includeConfiguredTabs mixin", () => {
+    const getStore = (helpConfig: any, multiSensitivity: boolean | undefined = undefined) => {
+        return new Vuex.Store<BasicState>({
+            state: mockBasicState({
+                config: {
+                    multiSensitivity,
+                    help: helpConfig
+                } as any
+            })
+        });
+    };
+
+    it("returns help tab name from store", () => {
+        const store = getStore({
+            markdown: ["test md"],
+            tabName: "Help"
+        });
+
+        const result = includeConfiguredTabs(store, ["Run", "Sensitivity"]);
+        expect(result.helpTabName.value).toBe("Help");
+        expect(result.multiSensitivityTabName.value).toBe(null);
+        expect(result.rightTabNames.value).toStrictEqual(["Help", "Run", "Sensitivity"]);
+    });
+
+    it("returns default help tab name", () => {
+        const store = getStore({
+            markdown: ["test md"]
+        }, false);
+
+        const result = includeConfiguredTabs(store, ["Run", "Sensitivity"]);
+        expect(result.helpTabName.value).toBe("Explanation");
+        expect(result.multiSensitivityTabName.value).toBe(null);
+        expect(result.rightTabNames.value).toStrictEqual(["Explanation", "Run", "Sensitivity"]);
+    });
+
+    it("returns no help tab name if no help markdown in store", () => {
+        const store = getStore({
+            tabName: "not used"
+        });
+
+        const result = includeConfiguredTabs(store, ["Run", "Sensitivity"]);
+        expect(result.helpTabName.value).toBe(null);
+        expect(result.multiSensitivityTabName.value).toBe(null);
+        expect(result.rightTabNames.value).toStrictEqual(["Run", "Sensitivity"]);
+    });
+
+    it("includes multi-sensitivity tab name if configured", () => {
+        const store = getStore({}, true);
+        const result = includeConfiguredTabs(store, ["Run", "Sensitivity"]);
+        expect(result.helpTabName.value).toBe(null);
+        expect(result.multiSensitivityTabName.value).toBe("Multi-sensitivity");
+        expect(result.rightTabNames.value).toStrictEqual(["Run", "Sensitivity", "Multi-sensitivity"]);
+    });
+
+    it("includes both help and multi-sensitivity tab names if configured", () => {
+        const store = getStore({
+            markdown: ["test md"],
+            tabName: "Help"
+        }, true);
+        const result = includeConfiguredTabs(store, ["Run", "Sensitivity"]);
+        expect(result.helpTabName.value).toBe("Help");
+        expect(result.multiSensitivityTabName.value).toBe("Multi-sensitivity");
+        expect(result.rightTabNames.value).toStrictEqual(["Help", "Run", "Sensitivity", "Multi-sensitivity"]);
+    });
+});
diff --git a/app/static/tests/unit/components/mixins/includeHelpTab.test.ts b/app/static/tests/unit/components/mixins/includeHelpTab.test.ts
deleted file mode 100644
index a71326f3c..000000000
--- a/app/static/tests/unit/components/mixins/includeHelpTab.test.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-import Vuex from "vuex";
-import { BasicState } from "../../../../src/app/store/basic/state";
-import { mockBasicState } from "../../../mocks";
-import includeHelpTab from "../../../../src/app/components/mixins/includeHelpTab";
-
-describe("includeHelpTab mixin", () => {
-    const getStore = (helpConfig: any) => {
-        return new Vuex.Store<BasicState>({
-            state: mockBasicState({
-                config: {
-                    help: helpConfig
-                } as any
-            })
-        });
-    };
-
-    it("returns help tab name from store", () => {
-        const store = getStore({
-            markdown: ["test md"],
-            tabName: "Help"
-        });
-
-        const result = includeHelpTab(store, ["Run", "Sensitivity"]);
-        expect(result.helpTabName.value).toBe("Help");
-        expect(result.rightTabNames.value).toStrictEqual(["Help", "Run", "Sensitivity"]);
-    });
-
-    it("returns default help tab name", () => {
-        const store = getStore({
-            markdown: ["test md"]
-        });
-
-        const result = includeHelpTab(store, ["Run", "Sensitivity"]);
-        expect(result.helpTabName.value).toBe("Explanation");
-        expect(result.rightTabNames.value).toStrictEqual(["Explanation", "Run", "Sensitivity"]);
-    });
-
-    it("returns no help tab name if no help markdown in store", () => {
-        const store = getStore({
-            tabName: "not used"
-        });
-
-        const result = includeHelpTab(store, ["Run", "Sensitivity"]);
-        expect(result.helpTabName.value).toBe(null);
-        expect(result.rightTabNames.value).toStrictEqual(["Run", "Sensitivity"]);
-    });
-});
diff --git a/app/static/tests/unit/components/multiSensitivity/multiSensitivityTab.test.ts b/app/static/tests/unit/components/multiSensitivity/multiSensitivityTab.test.ts
new file mode 100644
index 000000000..3fa23031e
--- /dev/null
+++ b/app/static/tests/unit/components/multiSensitivity/multiSensitivityTab.test.ts
@@ -0,0 +1,9 @@
+import { shallowMount } from "@vue/test-utils";
+import MultiSensitivityTab from "../../../../src/app/components/multiSensitivity/MultiSensitivityTab.vue";
+
+describe("MultiSensitivityTab", () => {
+    it("renders as expected", () => {
+        const wrapper = shallowMount(MultiSensitivityTab);
+        expect(wrapper.text()).toBe("Multi-sensitivity coming soon!");
+    });
+});
diff --git a/app/static/tests/unit/components/options/editParamSettings.test.ts b/app/static/tests/unit/components/options/editParamSettings.test.ts
index 7be2693b0..2a3046816 100644
--- a/app/static/tests/unit/components/options/editParamSettings.test.ts
+++ b/app/static/tests/unit/components/options/editParamSettings.test.ts
@@ -61,8 +61,7 @@ describe("EditParamSettings", () => {
 
     const parameterValues = { A: 1, B: 2, C: 3 };
 
-    const getWrapper = async (paramSettings: SensitivityParameterSettings, open = true,
-        mockSetParamSettings = jest.fn()) => {
+    const getWrapper = async (paramSettings: SensitivityParameterSettings, open = true) => {
         const store = new Vuex.Store<BasicState>({
             state: mockBasicState(),
             modules: {
@@ -77,15 +76,6 @@ describe("EditParamSettings", () => {
                     state: mockRunState({
                         parameterValues
                     })
-                },
-                sensitivity: {
-                    namespaced: true,
-                    state: {
-                        paramSettings
-                    },
-                    mutations: {
-                        [SensitivityMutation.SetParamSettings]: mockSetParamSettings
-                    }
                 }
             }
         });
@@ -95,7 +85,8 @@ describe("EditParamSettings", () => {
                 directives: { tooltip: mockTooltipDirective }
             },
             props: {
-                open: false
+                open: false,
+                paramSettings
             }
         });
 
@@ -234,9 +225,8 @@ describe("EditParamSettings", () => {
         await select.trigger("change");
     };
 
-    it("updates param settings and closes on OK click", async () => {
-        const mockSetParamSettings = jest.fn();
-        const wrapper = await getWrapper(percentSettings, true, mockSetParamSettings);
+    it("emits update and closes on OK click", async () => {
+        const wrapper = await getWrapper(percentSettings, true);
 
         await updateSelect(wrapper, "edit-param-to-vary", "A");
         await updateSelect(wrapper, "edit-scale-type", SensitivityScaleType.Logarithmic);
@@ -248,8 +238,8 @@ describe("EditParamSettings", () => {
 
         await wrapper.find("#ok-settings").trigger("click");
         expect(wrapper.emitted("close")?.length).toBe(1);
-        expect(mockSetParamSettings).toHaveBeenCalledTimes(1);
-        expect(mockSetParamSettings.mock.calls[0][1]).toStrictEqual({
+        expect(wrapper.emitted("update")?.length).toBe(1);
+        expect(wrapper.emitted("update")![0]).toStrictEqual([{
             parameterToVary: "A",
             scaleType: SensitivityScaleType.Logarithmic,
             variationType: SensitivityVariationType.Range,
@@ -258,7 +248,7 @@ describe("EditParamSettings", () => {
             rangeTo: 3,
             numberOfRuns: 11,
             customValues: []
-        });
+        }]);
     });
 
     it("renders and updates sensitivity param values", async () => {
@@ -305,25 +295,17 @@ describe("EditParamSettings", () => {
 
     it("updates values from TagInput", async () => {
         const mockSetParamSettings = jest.fn();
-        const wrapper = await getWrapper(customSettings, true, mockSetParamSettings);
+        const wrapper = await getWrapper(customSettings, true);
         const expectedValues = [-1, 0, 1];
         wrapper.findComponent(TagInput).vm.$emit("update", expectedValues);
-        await nextTick();
-        expect((wrapper.vm as any).settingsInternal.customValues).toStrictEqual(expectedValues);
-        await wrapper.find("#ok-settings").trigger("click");
-        expect(mockSetParamSettings).toHaveBeenCalledTimes(1);
-        const committed = mockSetParamSettings.mock.calls[0][1];
-        expect(committed.customValues).toStrictEqual(expectedValues);
+        expect((wrapper.vm as any).settingsInternal.customValues).toStrictEqual([-1, 0, 1]);
     });
 
-    it("sorts custom values on commit", async () => {
+    it("sorts custom values on update", async () => {
         const mockSetParamSettings = jest.fn();
-        const wrapper = await getWrapper(customSettings, true, mockSetParamSettings);
+        const wrapper = await getWrapper(customSettings, true);
         wrapper.findComponent(TagInput).vm.$emit("update", [5, 1, 0, -2, -1]);
         await wrapper.find("#ok-settings").trigger("click");
-        expect(mockSetParamSettings.mock.calls[0][1]).toStrictEqual({
-            ...customSettings,
-            customValues: [-2, -1, 0, 1, 5]
-        });
+        expect((wrapper.emitted("update")![0] as any)[0].customValues).toStrictEqual([-2, -1, 0, 1, 5]);
     });
 });
diff --git a/app/static/tests/unit/components/options/optionsTab.test.ts b/app/static/tests/unit/components/options/optionsTab.test.ts
index f7540772f..34e2adafe 100644
--- a/app/static/tests/unit/components/options/optionsTab.test.ts
+++ b/app/static/tests/unit/components/options/optionsTab.test.ts
@@ -255,6 +255,18 @@ describe("OptionsTab", () => {
                         parameterValues: { param1: 1, param2: 2.2 }
                     }),
                     getters: runGetters
+                },
+                multiSensitivity: {
+                    namespaced: true,
+                    state: {
+                        paramSettings: []
+                    }
+                },
+                sensitivity: {
+                    namespaced: true,
+                    state: {
+                        paramSettings: []
+                    }
                 }
             }
         });
@@ -263,4 +275,29 @@ describe("OptionsTab", () => {
         expect(wrapper.find("#reset-params-btn").exists()).toBe(true);
         expect(wrapper.find("#reset-params-btn").text()).toBe("Reset");
     });
+
+    it("renders as expected when multi-sensitivity tab is open", () => {
+        const store = new Vuex.Store<BasicState>({
+            state: {
+                ...fitAppState,
+                openVisualisationTab: VisualisationTab.MultiSensitivity
+            },
+            modules: {
+                run: {
+                    namespaced: true,
+                    state: mockRunState({
+                        parameterValues: { param1: 1, param2: 2.2 }
+                    }),
+                    getters: runGetters
+                }
+            }
+        });
+        const wrapper = shallowMount(OptionsTab, {
+            global: {
+                plugins: [store],
+                directives: { tooltip: mockTooltipDirective }
+            }
+        });
+        expect(wrapper.findComponent(SensitivityOptions).exists()).toBe(true);
+    });
 });
diff --git a/app/static/tests/unit/components/options/sensitivityOptions.test.ts b/app/static/tests/unit/components/options/sensitivityOptions.test.ts
index 7594bcb75..c3e61c1c3 100644
--- a/app/static/tests/unit/components/options/sensitivityOptions.test.ts
+++ b/app/static/tests/unit/components/options/sensitivityOptions.test.ts
@@ -1,5 +1,5 @@
 import Vuex from "vuex";
-import { mount } from "@vue/test-utils";
+import { DOMWrapper, mount, VueWrapper } from "@vue/test-utils";
 import {
     SensitivityParameterSettings,
     SensitivityScaleType,
@@ -12,17 +12,41 @@ import EditParamSettings from "../../../../src/app/components/options/EditParamS
 import { SensitivityGetter } from "../../../../src/app/store/sensitivity/getters";
 import SensitivityParamValues from "../../../../src/app/components/options/SensitivityParamValues.vue";
 import SensitivityPlotOptions from "../../../../src/app/components/options/SensitivityPlotOptions.vue";
+import { MultiSensitivityGetter } from "../../../../src/app/store/multiSensitivity/getters";
+import { BatchPars } from "../../../../src/app/types/responseTypes";
+import { SensitivityMutation } from "../../../../src/app/store/sensitivity/mutations";
+import { MultiSensitivityMutation } from "../../../../src/app/store/multiSensitivity/mutations";
+import { defaultSensitivityParamSettings } from "../../../../src/app/store/sensitivity/sensitivity";
 
 const mockTooltipDirective = jest.fn();
 
 describe("SensitivityOptions", () => {
     const mockBatchPars = {
         varying: [{
-            name: "B",
+            name: "A",
             values: [1, 2, 3]
         }]
     } as any;
 
+    const mockMultiBatchPars = [
+        mockBatchPars,
+        {
+            varying: [{
+                name: "B",
+                values: [4, 5]
+            }]
+        },
+        {
+            varying: [{
+                name: "C",
+                values: [6, 7, 8]
+            }]
+        }
+    ] as any;
+
+    const mockSensitivitySetParamSettings = jest.fn();
+    const mockMultiSensitivitySetParamSettings = jest.fn();
+
     const getWrapper = (paramSettings: SensitivityParameterSettings) => {
         const store = new Vuex.Store<BasicState>({
             state: {} as any,
@@ -35,6 +59,15 @@ describe("SensitivityOptions", () => {
                     },
                     getters: {
                         [SensitivityGetter.batchPars]: () => mockBatchPars
+                    },
+                    mutations: {
+                        [SensitivityMutation.SetParamSettings]: mockSensitivitySetParamSettings
+                    }
+                },
+                multiSensitivity: {
+                    namespaced: true,
+                    state: {
+                        paramSettings: []
                     }
                 },
                 model: {
@@ -48,6 +81,7 @@ describe("SensitivityOptions", () => {
             } as any
         });
         return mount(SensitivityOptions, {
+            props: { multiSensitivity: false },
             global: {
                 plugins: [store],
                 directives: { tooltip: mockTooltipDirective }
@@ -55,8 +89,54 @@ describe("SensitivityOptions", () => {
         });
     };
 
+    const getWrapperForMultiSensitivity = ((paramSettings: SensitivityParameterSettings[]) => {
+        const store = new Vuex.Store<BasicState>({
+            state: {} as any,
+            modules: {
+                multiSensitivity: {
+                    namespaced: true,
+                    state: {
+                        paramSettings
+                    },
+                    getters: {
+                        [MultiSensitivityGetter.multiBatchPars]: () => mockMultiBatchPars
+                    },
+                    mutations: {
+                        [MultiSensitivityMutation.SetParamSettings]: mockMultiSensitivitySetParamSettings
+                    }
+                },
+                model: {
+                },
+                run: {
+                    namespaced: true,
+                    state: {
+                        parameterValues: {
+                            A: 1,
+                            B: 2,
+                            C: 3,
+                            D: 4
+                        }
+                    }
+                },
+                sensitivity: {
+                    namespaced: true,
+                    state: {
+                        plotSettings: {}
+                    }
+                }
+            } as any
+        });
+        return mount(SensitivityOptions, {
+            props: { multiSensitivity: true },
+            global: {
+                plugins: [store],
+                directives: { tooltip: mockTooltipDirective }
+            }
+        });
+    });
+
     const percentSettings = {
-        parameterToVary: "B",
+        parameterToVary: "A",
         scaleType: SensitivityScaleType.Arithmetic,
         variationType: SensitivityVariationType.Percentage,
         variationPercentage: 10,
@@ -66,43 +146,76 @@ describe("SensitivityOptions", () => {
         customValues: []
     };
 
-    it("displays percentage variance as expected", () => {
-        const wrapper = getWrapper(percentSettings);
+    const rangeSettings = {
+        parameterToVary: "B",
+        scaleType: SensitivityScaleType.Logarithmic,
+        variationType: SensitivityVariationType.Range,
+        variationPercentage: 10,
+        rangeFrom: 1,
+        rangeTo: 3,
+        numberOfRuns: 5,
+        customValues: []
+    };
 
-        expect(wrapper.findComponent(VerticalCollapse).props("title")).toBe("Sensitivity Options");
-        expect(wrapper.findComponent(VerticalCollapse).props("collapseId")).toBe("sensitivity-options");
+    const customSettings = {
+        parameterToVary: "C",
+        scaleType: SensitivityScaleType.Logarithmic,
+        variationType: SensitivityVariationType.Custom,
+        variationPercentage: 10,
+        rangeFrom: 1,
+        rangeTo: 3,
+        numberOfRuns: 5,
+        customValues: [1, 2, 3]
+    };
+
+    const expectEditButton = (wrapper: DOMWrapper<Element>) => {
+        expect(wrapper.find(".edit-param-settings").exists()).toBe(true);
+    };
 
+    const expectDeleteButton = (wrapper: DOMWrapper<Element>, exists = true) => {
+        expect(wrapper.find(".delete-param-settings").exists()).toBe(exists);
+    };
+
+    const expectAddButton = (wrapper: VueWrapper<any>, exists = true) => {
+        expect(wrapper.find("button.add-param-settings").exists()).toBe(exists);
+    };
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    const expectPercentSettings = (wrapper: DOMWrapper<Element>, batchPars: BatchPars) => {
         const listItems = wrapper.findAll("ul li");
         expect(listItems.length).toBe(5);
-        expect(listItems.at(0)!.text()).toBe("Parameter: B");
+        expect(listItems.at(0)!.text()).toBe("Parameter: A");
         expect(listItems.at(1)!.text()).toBe("Variation Type: Percentage");
         expect(listItems.at(2)!.text()).toBe("Scale Type: Arithmetic");
         expect(listItems.at(3)!.text()).toBe("Variation (%): 10");
         expect(listItems.at(4)!.text()).toBe("Number of runs: 5");
 
-        expect(wrapper.find("#sensitivity-options").findComponent(SensitivityParamValues)
-            .props("batchPars")).toBe(mockBatchPars);
+        expect(wrapper.findComponent(SensitivityParamValues).props("batchPars")).toBe(batchPars);
 
-        expect(wrapper.find("button.btn-primary").text()).toBe("Edit");
+        expectEditButton(wrapper);
+    };
+
+    it("displays percentage variance as expected", () => {
+        const wrapper = getWrapper(percentSettings);
+
+        expect(wrapper.findComponent(VerticalCollapse).props("title")).toBe("Sensitivity Options");
+        expect(wrapper.findComponent(VerticalCollapse).props("collapseId")).toBe("sensitivity-options");
+
+        const optionsSettings = wrapper.find(".sensitivity-options-settings");
+        expectPercentSettings(optionsSettings, mockBatchPars);
         expect(wrapper.findComponent(EditParamSettings).props("open")).toBe(false);
 
         expect(wrapper.find("#sensitivity-options-msg").exists()).toBe(false);
 
         expect(wrapper.findComponent(SensitivityPlotOptions).exists()).toBe(true);
+        expectDeleteButton(optionsSettings, false);
+        expectAddButton(wrapper, false);
     });
 
-    it("displays range variance as expected", () => {
-        const wrapper = getWrapper({
-            parameterToVary: "B",
-            scaleType: SensitivityScaleType.Logarithmic,
-            variationType: SensitivityVariationType.Range,
-            variationPercentage: 10,
-            rangeFrom: 1,
-            rangeTo: 3,
-            numberOfRuns: 5,
-            customValues: []
-        });
-
+    const expectRangeSettings = (wrapper: DOMWrapper<Element>, batchPars: BatchPars) => {
         const listItems = wrapper.findAll("ul li");
         expect(listItems.length).toBe(6);
         expect(listItems.at(0)!.text()).toBe("Parameter: B");
@@ -111,37 +224,86 @@ describe("SensitivityOptions", () => {
         expect(listItems.at(3)!.text()).toBe("From: 1");
         expect(listItems.at(4)!.text()).toBe("To: 3");
         expect(listItems.at(5)!.text()).toBe("Number of runs: 5");
-    });
 
-    it("displays custom values as expected", () => {
-        const wrapper = getWrapper({
-            parameterToVary: "C",
-            scaleType: SensitivityScaleType.Logarithmic,
-            variationType: SensitivityVariationType.Custom,
-            variationPercentage: 10,
-            rangeFrom: 1,
-            rangeTo: 3,
-            numberOfRuns: 5,
-            customValues: [1, 2, 3]
-        });
+        expect(wrapper.findComponent(SensitivityParamValues).props("batchPars")).toBe(batchPars);
+        expectEditButton(wrapper);
+    };
 
+    it("displays range variance as expected", () => {
+        const wrapper = getWrapper(rangeSettings);
+        const optionsSettings = wrapper.find(".sensitivity-options-settings");
+        expectRangeSettings(optionsSettings, mockBatchPars);
+        expectDeleteButton(optionsSettings, false);
+        expectAddButton(wrapper, false);
+    });
+
+    const expectCustomSettings = (wrapper: DOMWrapper<Element>) => {
         const listItems = wrapper.findAll("ul li");
         expect(listItems.length).toBe(3);
         expect(listItems.at(0)!.text()).toBe("Parameter: C");
         expect(listItems.at(1)!.text()).toBe("Variation Type: Custom");
         expect(listItems.at(2)!.text()).toBe("Values: 1, 2, 3");
+        expect(wrapper.findComponent(SensitivityParamValues).exists()).toBe(false);
+        expectEditButton(wrapper);
+    };
+
+    it("displays custom values as expected", () => {
+        const wrapper = getWrapper(customSettings);
+        const optionsSettings = wrapper.find(".sensitivity-options-settings");
+        expectCustomSettings(optionsSettings);
+        expectDeleteButton(optionsSettings, false);
+        expectAddButton(wrapper, false);
     });
 
-    it("opens and closes edit dialog", async () => {
+    it("renders as expected for multi-sensitivity", () => {
+        const wrapper = getWrapperForMultiSensitivity([
+            percentSettings,
+            rangeSettings,
+            customSettings
+        ]);
+        expect(wrapper.findComponent(VerticalCollapse).props("title")).toBe("Multi-sensitivity Options");
+        expect(wrapper.findComponent(VerticalCollapse).props("collapseId")).toBe("sensitivity-options");
+        const allSettingsDivs = wrapper.findAll(".sensitivity-options-settings");
+        expect(allSettingsDivs.length).toBe(3);
+        expectPercentSettings(allSettingsDivs[0], mockMultiBatchPars[0]);
+        expectDeleteButton(allSettingsDivs[0]);
+
+        expectRangeSettings(allSettingsDivs[1], mockMultiBatchPars[1]);
+        expectDeleteButton(allSettingsDivs[1]);
+
+        expectCustomSettings(allSettingsDivs[2]);
+        expectDeleteButton(allSettingsDivs[2]);
+
+        expectAddButton(wrapper);
+    });
+
+    it("opens and closes edit dialog for sensitivity", async () => {
         const wrapper = getWrapper(percentSettings);
-        await wrapper.find("button,btn-primary").trigger("click");
+        await wrapper.find(".edit-param-settings").trigger("click");
         const editParamSettings = wrapper.findComponent(EditParamSettings);
         expect(editParamSettings.props("open")).toBe(true);
+        expect(editParamSettings.props("paramSettings")).toStrictEqual(percentSettings);
 
         await editParamSettings.vm.$emit("close");
         expect(editParamSettings.props("open")).toBe(false);
     });
 
+    it("opens and closes edit dialog for multi-sensitivity", async () => {
+        const wrapper = getWrapperForMultiSensitivity([percentSettings, rangeSettings]);
+        const allSettingsDivs = wrapper.findAll(".sensitivity-options-settings");
+        await allSettingsDivs[0].find(".edit-param-settings").trigger("click");
+        const editParamSettings = wrapper.findComponent(EditParamSettings);
+        expect(editParamSettings.props("open")).toBe(true);
+        expect(editParamSettings.props("paramSettings")).toStrictEqual(percentSettings);
+
+        await editParamSettings.vm.$emit("close");
+        expect(editParamSettings.props("open")).toBe(false);
+
+        await allSettingsDivs[1].find(".edit-param-settings").trigger("click");
+        expect(editParamSettings.props("open")).toBe(true);
+        expect(editParamSettings.props("paramSettings")).toStrictEqual(rangeSettings);
+    });
+
     it("displays message if no parameter to vary", () => {
         const wrapper = getWrapper({ parameterToVary: null } as any);
         expect(wrapper.find("ul").exists()).toBe(false);
@@ -150,4 +312,91 @@ describe("SensitivityOptions", () => {
         expect(wrapper.find("#sensitivity-options").findComponent(SensitivityParamValues).exists()).toBe(false);
         expect(wrapper.findComponent(SensitivityPlotOptions).exists()).toBe(false);
     });
+
+    it("saves edited sensitivity param settings", async () => {
+        const wrapper = getWrapper(percentSettings);
+        await wrapper.find(".edit-param-settings").trigger("click");
+        const editParamSettings = wrapper.findComponent(EditParamSettings);
+        await editParamSettings.vm.$emit("update", { ...rangeSettings });
+        expect(mockSensitivitySetParamSettings).toHaveBeenCalledTimes(1);
+        expect(mockSensitivitySetParamSettings.mock.calls[0][1]).toStrictEqual(rangeSettings);
+        expect(mockMultiSensitivitySetParamSettings).not.toHaveBeenCalled();
+    });
+
+    it("saves edited multi-sensitivity param settings", async () => {
+        const wrapper = getWrapperForMultiSensitivity([customSettings, percentSettings]);
+        const allSettingsDivs = wrapper.findAll(".sensitivity-options-settings");
+        await allSettingsDivs[1].find(".edit-param-settings").trigger("click");
+        const editParamSettings = wrapper.findComponent(EditParamSettings);
+        await editParamSettings.vm.$emit("update", { ...rangeSettings });
+        expect(mockMultiSensitivitySetParamSettings).toHaveBeenCalledTimes(1);
+        expect(mockMultiSensitivitySetParamSettings.mock.calls[0][1]).toStrictEqual([customSettings, rangeSettings]);
+        expect(mockSensitivitySetParamSettings).not.toHaveBeenCalled();
+    });
+
+    it("opens editor with default new settings when click Add button", async () => {
+        const settings = [customSettings, percentSettings];
+        const wrapper = getWrapperForMultiSensitivity(settings);
+        await wrapper.find("#add-param-settings").trigger("click");
+
+        const editParamSettings = wrapper.findComponent(EditParamSettings);
+        expect(editParamSettings.props("open")).toBe(true);
+        expect(editParamSettings.props("paramSettings")).toStrictEqual({
+            ...defaultSensitivityParamSettings(),
+            parameterToVary: "B"
+        });
+        expect(mockMultiSensitivitySetParamSettings).not.toHaveBeenCalled();
+    });
+
+    it("saves added multi-sensitivity param settings", async () => {
+        const settings = [customSettings, percentSettings];
+        const wrapper = getWrapperForMultiSensitivity(settings);
+        await wrapper.find("#add-param-settings").trigger("click");
+        const editParamSettings = wrapper.findComponent(EditParamSettings);
+        await editParamSettings.vm.$emit("update", { ...rangeSettings });
+        expect(mockMultiSensitivitySetParamSettings).toHaveBeenCalledTimes(1);
+        // The first parameter not already in the settings should be B
+        expect(mockMultiSensitivitySetParamSettings.mock.calls[0][1]).toStrictEqual([
+            ...settings,
+            rangeSettings
+        ]);
+    });
+
+    it("can edit setting after closing editor on add", async () => {
+        const settings = [customSettings, percentSettings];
+        const wrapper = getWrapperForMultiSensitivity(settings);
+        await wrapper.find("#add-param-settings").trigger("click");
+        expect((wrapper.vm as any).addingParamSettings).toBe(true);
+        const editParamSettings = wrapper.findComponent(EditParamSettings);
+        editParamSettings.vm.$emit("close");
+        expect((wrapper.vm as any).addingParamSettings).toBe(false);
+        await wrapper.find(".edit-param-settings").trigger("click");
+        expect(editParamSettings.props("paramSettings")).toStrictEqual(customSettings);
+    });
+
+    it("deletes param settings when click Delete button", async () => {
+        const settings = [customSettings, percentSettings, rangeSettings];
+        const wrapper = getWrapperForMultiSensitivity(settings);
+        const allSettingsDivs = wrapper.findAll(".sensitivity-options-settings");
+        await allSettingsDivs[1].find(".delete-param-settings").trigger("click");
+        expect(mockMultiSensitivitySetParamSettings).toHaveBeenCalledTimes(1);
+        // The first parameter not already in the settings should be B
+        expect(mockMultiSensitivitySetParamSettings.mock.calls[0][1])
+            .toStrictEqual([customSettings, rangeSettings]);
+    });
+
+    it("does not display delete button when there is only one param settings", () => {
+        const wrapper = getWrapperForMultiSensitivity([percentSettings]);
+        expect(wrapper.find(".delete-param-settings").exists()).toBe(false);
+    });
+
+    it("removes add button when all parameters have settings", () => {
+        const wrapper = getWrapperForMultiSensitivity([
+            percentSettings, // param A
+            rangeSettings, // param B
+            customSettings, // param C
+            { ...rangeSettings, parameterToVary: "D" }
+        ]);
+        expect(wrapper.find("#add-param-settings").exists()).toBe(false);
+    });
 });
diff --git a/app/static/tests/unit/components/stochastic/stochasticApp.test.ts b/app/static/tests/unit/components/stochastic/stochasticApp.test.ts
index 3af442700..632a8601b 100644
--- a/app/static/tests/unit/components/stochastic/stochasticApp.test.ts
+++ b/app/static/tests/unit/components/stochastic/stochasticApp.test.ts
@@ -13,6 +13,7 @@ jest.mock("../../../../src/app/components/help/MarkdownItImport.ts", () => {
 /* eslint-disable import/first */
 import Vuex from "vuex";
 import { mount } from "@vue/test-utils";
+import { expectLeftWodinTabs, expectRightWodinTabs } from "../../../testUtils";
 import StochasticApp from "../../../../src/app/components/stochastic/StochasticApp.vue";
 import { StochasticState } from "../../../../src/app/store/stochastic/state";
 import { mockModelState, mockGraphSettingsState, mockStochasticState } from "../../../mocks";
@@ -22,6 +23,7 @@ import CodeTab from "../../../../src/app/components/code/CodeTab.vue";
 import OptionsTab from "../../../../src/app/components/options/OptionsTab.vue";
 import RunTab from "../../../../src/app/components/run/RunTab.vue";
 import SensitivityTab from "../../../../src/app/components/sensitivity/SensitivityTab.vue";
+import MultiSensitivityTab from "../../../../src/app/components/multiSensitivity/MultiSensitivityTab.vue";
 import HelpTab from "../../../../src/app/components/help/HelpTab.vue";
 import { ModelAction } from "../../../../src/app/store/model/actions";
 import { AppStateAction } from "../../../../src/app/store/appState/actions";
@@ -86,20 +88,14 @@ describe("StochasticApp", () => {
         const wodinApp = wrapper.findComponent(WodinApp);
 
         const wodinPanels = wodinApp.findComponent(WodinPanels);
-        const leftPanel = wodinPanels.find(".wodin-left");
-        const leftTabs = leftPanel.find("#left-tabs");
-        const leftTabLinks = leftTabs.findAll("ul li a");
-        expect(leftTabLinks.length).toBe(2);
-        expect(leftTabLinks.at(0)!.text()).toBe("Code");
-        expect(leftTabLinks.at(1)!.text()).toBe("Options");
+
+        expectLeftWodinTabs(wrapper, ["Code", "Options"]);
+
+        const leftTabs = wodinPanels.find(".wodin-left #left-tabs");
         expect(leftTabs.findComponent(CodeTab).exists()).toBe(true);
 
-        const rightPanel = wodinPanels.find(".wodin-right");
-        const rightTabs = rightPanel.find("#right-tabs");
-        const rightTabLinks = rightTabs.findAll("ul li a");
-        expect(rightTabLinks.length).toBe(2);
-        expect(rightTabLinks.at(0)!.text()).toBe("Run");
-        expect(rightTabLinks.at(1)!.text()).toBe("Sensitivity");
+        expectRightWodinTabs(wrapper, ["Run", "Sensitivity"]);
+        const rightTabs = wodinPanels.find(".wodin-right #right-tabs");
         expect(rightTabs.findComponent(RunTab).exists()).toBe(true);
     });
 
@@ -139,13 +135,36 @@ describe("StochasticApp", () => {
         };
         const wrapper = getWrapper(helpConfig);
         const wodinPanels = wrapper.findComponent(WodinPanels);
-        const rightPanel = wodinPanels.find(".wodin-right");
-        const rightTabs = rightPanel.find("#right-tabs");
-        const rightTabLinks = rightTabs.findAll("ul li a");
-        expect(rightTabLinks.length).toBe(3);
-        expect(rightTabLinks.at(0)!.text()).toBe("Help");
-        expect(rightTabLinks.at(1)!.text()).toBe("Run");
-        expect(rightTabLinks.at(2)!.text()).toBe("Sensitivity");
+        expectRightWodinTabs(wrapper, ["Help", "Run", "Sensitivity"]);
+
+        const rightTabs = wodinPanels.find(".wodin-right #right-tabs");
         expect(rightTabs.findComponent(HelpTab).exists()).toBe(true);
     });
+
+    it("renders Multi-sensitivity tab if configured", async () => {
+        const multiSensConfig = {
+            multiSensitivity: true
+        };
+        const wrapper = getWrapper(multiSensConfig);
+        const wodinPanels = wrapper.findComponent(WodinPanels);
+
+        expectRightWodinTabs(wrapper, ["Run", "Sensitivity", "Multi-sensitivity"]);
+        // Change to Options tab
+        const rightTabs = wodinPanels.find(".wodin-right #right-tabs");
+        const rightTabLinks = rightTabs.findAll("ul li a");
+        await rightTabLinks.at(2)!.trigger("click");
+        expect(rightTabs.findComponent(MultiSensitivityTab).exists()).toBe(true);
+    });
+
+    it("renders both Help and MultiSensitivity if configured", () => {
+        const bothConfig = {
+            help: {
+                markdown: ["test md"],
+                tabName: "Help"
+            },
+            multiSensitivity: true
+        };
+        const wrapper = getWrapper(bothConfig);
+        expectRightWodinTabs(wrapper, ["Help", "Run", "Sensitivity", "Multi-sensitivity"]);
+    });
 });
diff --git a/app/static/tests/unit/serialiser.test.ts b/app/static/tests/unit/serialiser.test.ts
index 2a9ae6500..c5203e92e 100644
--- a/app/static/tests/unit/serialiser.test.ts
+++ b/app/static/tests/unit/serialiser.test.ts
@@ -12,7 +12,7 @@ import {
     mockCodeState,
     mockFitDataState, mockGraphSettingsState,
     mockModelFitState,
-    mockModelState,
+    mockModelState, mockMultiSensitivityState,
     mockRunState,
     mockSensitivityState, mockVersionsState
 } from "../mocks";
@@ -272,6 +272,7 @@ describe("serialise", () => {
         model: modelState,
         run: runState,
         sensitivity: sensitivityState,
+        multiSensitivity: mockMultiSensitivityState(),
         versions: { versions: null },
         graphSettings: { logScaleYAxis: true },
         configured: false,
@@ -293,6 +294,7 @@ describe("serialise", () => {
         model: modelState,
         run: runState,
         sensitivity: sensitivityState,
+        multiSensitivity: mockMultiSensitivityState(),
         fitData: fitDataState,
         modelFit: modelFitState,
         versions: { versions: null },
diff --git a/app/static/tests/unit/store/model/actions.test.ts b/app/static/tests/unit/store/model/actions.test.ts
index eb5b6ab38..fab4b254f 100644
--- a/app/static/tests/unit/store/model/actions.test.ts
+++ b/app/static/tests/unit/store/model/actions.test.ts
@@ -20,6 +20,8 @@ import { ModelFitAction } from "../../../../src/app/store/modelFit/actions";
 import { RunMutation, mutations as runMutations } from "../../../../src/app/store/run/mutations";
 import { ModelFitMutation } from "../../../../src/app/store/modelFit/mutations";
 import { SensitivityMutation } from "../../../../src/app/store/sensitivity/mutations";
+import { MultiSensitivityMutation } from "../../../../src/app/store/multiSensitivity/mutations";
+import { defaultSensitivityParamSettings } from "../../../../src/app/store/sensitivity/sensitivity";
 
 describe("Model actions", () => {
     beforeEach(() => {
@@ -29,6 +31,9 @@ describe("Model actions", () => {
     const rootState = {
         appType: AppType.Basic,
         baseUrl: "",
+        config: {
+            multiSensitivity: true
+        },
         code: {
             currentCode: ["line1", "line2"]
         },
@@ -37,6 +42,12 @@ describe("Model actions", () => {
                 parameterToVary: null
             }
         },
+        multiSensitivity: {
+            paramSettings: [
+                { parameterToVary: "p1" },
+                { parameterToVary: "p2" }
+            ]
+        },
         run: {
             runRequired: {
                 modelChanged: false,
@@ -144,27 +155,30 @@ describe("Model actions", () => {
         expect(commit.mock.calls[0][1].detail).toBe("server error");
     });
 
+    const updatedParamState = {
+        odinModelResponse: {
+            model: "1+2",
+            metadata: {
+                parameters: [
+                    { name: "p2", default: 20 },
+                    { name: "p3", default: 30 },
+                    { name: "p4", default: 40 }
+                ],
+                variables: ["x", "y", "z"]
+            }
+        },
+        selectedVariables: ["x", "a"],
+        unselectedVariables: ["y", "b"],
+        compileRequired: true
+    };
+
     it("compiles model, sets parameter values and updates required action", () => {
-        const state = {
-            odinModelResponse: {
-                model: "1+2",
-                metadata: {
-                    parameters: [
-                        { name: "p2", default: 20 },
-                        { name: "p3", default: 30 },
-                        { name: "p4", default: 40 }
-                    ],
-                    variables: ["x", "y", "z"]
-                }
-            },
-            selectedVariables: ["x", "a"],
-            unselectedVariables: ["y", "b"],
-            compileRequired: true
-        };
         const commit = jest.fn();
         const dispatch = jest.fn();
-        (actions[ModelAction.CompileModel] as any)({ commit, state, rootState });
-        expect(commit.mock.calls.length).toBe(8);
+        (actions[ModelAction.CompileModel] as any)({
+            commit, dispatch, state: updatedParamState, rootState
+        });
+        expect(commit.mock.calls.length).toBe(9);
         expect(commit.mock.calls[0][0]).toBe(ModelMutation.SetOdin);
         expect(commit.mock.calls[0][1]).toBe(3);
         expect(commit.mock.calls[1][0]).toBe(`run/${RunMutation.SetParameterValues}`);
@@ -186,11 +200,54 @@ describe("Model actions", () => {
         expect(commit.mock.calls[7][0]).toBe(`sensitivity/${SensitivityMutation.SetParameterToVary}`);
         expect(commit.mock.calls[7][1]).toBe("p2");
         expect(commit.mock.calls[7][2]).toStrictEqual({ root: true });
+        // Should remove old parameter from multiSensitivity array, but leave the remaining parameter
+        expect(commit.mock.calls[8][0]).toBe(`multiSensitivity/${MultiSensitivityMutation.SetParamSettings}`);
+        expect(commit.mock.calls[8][1]).toStrictEqual([{ parameterToVary: "p2" }]);
+        expect(commit.mock.calls[8][2]).toStrictEqual({ root: true });
 
         // does not dispatch updated linked variables or update params to vary if app type is not Fit
         expect(dispatch).not.toHaveBeenCalled();
     });
 
+    it("compile does not update multiSensitivity param settings if multisensitivity is not configured", () => {
+        const noMultiSensRootState = {
+            ...rootState,
+            config: {
+                multiSensitivity: undefined
+            }
+        };
+        const commit = jest.fn();
+        const dispatch = jest.fn();
+        (actions[ModelAction.CompileModel] as any)({
+            commit, dispatch, state: updatedParamState, rootState: noMultiSensRootState
+        });
+        expect(commit.mock.calls.length).toBe(8);
+        expect(commit.mock.calls[7][0]).toBe(`sensitivity/${SensitivityMutation.SetParameterToVary}`);
+        expect(dispatch).not.toHaveBeenCalled();
+    });
+
+    it("compile updates multiSensitivity with default param settings if all previous settings are removed", () => {
+        const oldMultiSensRootState = {
+            ...rootState,
+            multiSensitivity: {
+                paramSettings: [
+                    { parameterToVary: "p1" }
+                ]
+            }
+        };
+        const commit = jest.fn();
+        (actions[ModelAction.CompileModel] as any)({
+            commit,
+            state: updatedParamState,
+            rootState: oldMultiSensRootState
+        });
+        expect(commit.mock.calls.length).toBe(9);
+        expect(commit.mock.calls[8][0]).toBe(`multiSensitivity/${MultiSensitivityMutation.SetParamSettings}`);
+        expect(commit.mock.calls[8][1])
+            .toStrictEqual([{ ...defaultSensitivityParamSettings(), parameterToVary: "p2" }]);
+        expect(commit.mock.calls[8][2]).toStrictEqual({ root: true });
+    });
+
     it("compile model dispatches update linked variables and update params to vary for Fit apps", () => {
         const state = {
             odinModelResponse: {
@@ -270,12 +327,18 @@ describe("Model actions", () => {
                 paramSettings: {
                     parameterToVary: "p2"
                 }
+            },
+            multiSensitivity: {
+                paramSettings: [
+                    { parameterToVary: "p2" },
+                    { parameterToVary: "p3" }
+                ]
             }
         } as any;
         (actions[ModelAction.CompileModel] as any)({
             commit, dispatch, state, rootState: testRootState
         });
-        expect(commit.mock.calls.length).toBe(7);
+        expect(commit.mock.calls.length).toBe(8);
         expect(commit.mock.calls[0][0]).toBe(ModelMutation.SetOdin);
         expect(commit.mock.calls[1][0]).toBe(`run/${RunMutation.SetParameterValues}`);
         expect(commit.mock.calls[2][0]).toBe(ModelMutation.SetPaletteModel);
@@ -284,6 +347,7 @@ describe("Model actions", () => {
         expect(commit.mock.calls[4][0]).toBe(ModelMutation.SetCompileRequired);
         expect(commit.mock.calls[5][0]).toBe(`run/${RunMutation.SetRunRequired}`);
         expect(commit.mock.calls[6][0]).toBe(`sensitivity/${SensitivityMutation.SetUpdateRequired}`);
+        expect(commit.mock.calls[7][0]).toBe(`multiSensitivity/${MultiSensitivityMutation.SetParamSettings}`);
     });
 
     it("compile model does not update runRequired or compileRequired if compileRequired was false", () => {
@@ -301,7 +365,7 @@ describe("Model actions", () => {
         });
         const commit = jest.fn();
         (actions[ModelAction.CompileModel] as any)({ commit, state, rootState });
-        expect(commit.mock.calls.length).toBe(5);
+        expect(commit.mock.calls.length).toBe(6);
         expect(commit.mock.calls[0][0]).toBe(ModelMutation.SetOdin);
         expect(commit.mock.calls[0][1]).toBe(3);
         expect(commit.mock.calls[1][0]).toBe(`run/${RunMutation.SetParameterValues}`);
@@ -311,6 +375,8 @@ describe("Model actions", () => {
         expect(commit.mock.calls[3][1]).toStrictEqual(["x", "y"]);
         expect(commit.mock.calls[4][0]).toBe(`sensitivity/${SensitivityMutation.SetParameterToVary}`);
         expect(commit.mock.calls[4][1]).toBe(null);
+        expect(commit.mock.calls[5][0]).toBe(`multiSensitivity/${MultiSensitivityMutation.SetParamSettings}`);
+        expect(commit.mock.calls[5][1]).toStrictEqual([defaultSensitivityParamSettings()]);
     });
 
     it("compile model does nothing if no odin response", () => {
diff --git a/app/static/tests/unit/store/multiSensitivity/getters.test.ts b/app/static/tests/unit/store/multiSensitivity/getters.test.ts
new file mode 100644
index 000000000..0486b790a
--- /dev/null
+++ b/app/static/tests/unit/store/multiSensitivity/getters.test.ts
@@ -0,0 +1,72 @@
+import { SensitivityScaleType, SensitivityVariationType } from "../../../../src/app/store/sensitivity/state";
+import {
+    mockBatchParsDisplace,
+    mockBatchParsRange,
+    mockMultiSensitivityState
+} from "../../../mocks";
+import { getters, MultiSensitivityGetter } from "../../../../src/app/store/multiSensitivity/getters";
+
+describe("MultiSensitivity getters", () => {
+    const paramSettings = [
+        {
+            parameterToVary: "A",
+            scaleType: SensitivityScaleType.Arithmetic,
+            variationType: SensitivityVariationType.Percentage,
+            variationPercentage: 50,
+            rangeFrom: 0,
+            rangeTo: 0,
+            numberOfRuns: 3,
+            customValues: []
+        },
+        {
+            parameterToVary: "B",
+            scaleType: SensitivityScaleType.Arithmetic,
+            variationType: SensitivityVariationType.Range,
+            variationPercentage: 50,
+            rangeFrom: 1,
+            rangeTo: 5,
+            numberOfRuns: 5,
+            customValues: []
+        }
+    ];
+
+    it("generates multiBatchPars", () => {
+        const parameterValues = { A: 2, B: 3 };
+        const odinRunnerOde = {
+            batchParsDisplace: mockBatchParsDisplace,
+            batchParsRange: mockBatchParsRange
+        };
+        const state = mockMultiSensitivityState({
+            paramSettings
+        });
+        const rootState = {
+            model: {
+                odinRunnerOde
+            },
+            run: {
+                parameterValues
+            }
+        } as any;
+
+        const mockSpyDisplace = jest.spyOn(odinRunnerOde, "batchParsDisplace");
+        const mockSpyRange = jest.spyOn(odinRunnerOde, "batchParsRange");
+
+        const result = getters[MultiSensitivityGetter.multiBatchPars](state, getters, rootState, {} as any);
+        expect(result).toStrictEqual([
+            {
+                varying: [
+                    { name: "A", values: [1, 2, 3] }
+                ],
+                base: parameterValues
+            },
+            {
+                varying: [
+                    { name: "B", values: [1, 2, 3, 4, 5] }
+                ],
+                base: parameterValues
+            }
+        ]);
+        expect(mockSpyDisplace).toHaveBeenCalledTimes(1);
+        expect(mockSpyRange).toHaveBeenCalledTimes(1);
+    });
+});
diff --git a/app/static/tests/unit/store/multiSensitivity/mutations.test.ts b/app/static/tests/unit/store/multiSensitivity/mutations.test.ts
new file mode 100644
index 000000000..2c6ecb21b
--- /dev/null
+++ b/app/static/tests/unit/store/multiSensitivity/mutations.test.ts
@@ -0,0 +1,11 @@
+import { mockMultiSensitivityState } from "../../../mocks";
+import { mutations, MultiSensitivityMutation } from "../../../../src/app/store/multiSensitivity/mutations";
+
+describe("MultiSensitivity mutations", () => {
+    it("Sets parameter settings", () => {
+        const state = mockMultiSensitivityState();
+        const paramSettings = [{ parameterToVary: "X" }, { parameterToVary: "Y" }] as any;
+        mutations[MultiSensitivityMutation.SetParamSettings](state, paramSettings);
+        expect(state.paramSettings).toBe(paramSettings);
+    });
+});
diff --git a/config/apps/day1.config.json b/config/apps/day1.config.json
index d166b5b53..76f2a811b 100644
--- a/config/apps/day1.config.json
+++ b/config/apps/day1.config.json
@@ -3,5 +3,6 @@
   "title": "Day 1 - Basic Model",
   "basicProp": "day1 basic value",
   "readOnlyCode": false,
-  "stateUploadIntervalMillis": 2000
+  "stateUploadIntervalMillis": 2000,
+  "multiSensitivity": true
 }
diff --git a/config/apps/day2.config.json b/config/apps/day2.config.json
index 82c89ede1..2ebf3eaee 100644
--- a/config/apps/day2.config.json
+++ b/config/apps/day2.config.json
@@ -2,5 +2,6 @@
   "appType": "fit",
   "title": "Day 2 - Model Fit",
   "fitProp": "day2 fit value",
-  "readOnlyCode": false
+  "readOnlyCode": false,
+  "multiSensitivity": true
 }