diff --git a/js_modules/dagster-ui/packages/ui-core/src/app/Telemetry.tsx b/js_modules/dagster-ui/packages/ui-core/src/app/Telemetry.tsx
index ce8133c042eb1..291afd68962fc 100644
--- a/js_modules/dagster-ui/packages/ui-core/src/app/Telemetry.tsx
+++ b/js_modules/dagster-ui/packages/ui-core/src/app/Telemetry.tsx
@@ -9,6 +9,7 @@ import {gql} from '../apollo-client';
 
 export enum TelemetryAction {
   LAUNCH_RUN = 'LAUNCH_RUN',
+  LAUNCH_MULTIPLE_RUNS = 'LAUNCH_MULTIPLE_RUNS',
   GRAPHQL_QUERY_COMPLETED = 'GRAPHQL_QUERY_COMPLETED',
 }
 
@@ -38,7 +39,7 @@ const LOG_TELEMETRY_MUTATION = gql`
 export async function logTelemetry(
   pathPrefix: string,
   action: TelemetryAction,
-  metadata: {[key: string]: string | null | undefined} = {},
+  metadata: {[key: string]: string | string[] | null | undefined} = {},
 ) {
   const graphqlPath = `${pathPrefix || ''}/graphql`;
 
@@ -63,7 +64,10 @@ export async function logTelemetry(
 export const useTelemetryAction = () => {
   const {basePath, telemetryEnabled} = useContext(AppContext);
   return useCallback(
-    (action: TelemetryAction, metadata: {[key: string]: string | null | undefined} = {}) => {
+    (
+      action: TelemetryAction,
+      metadata: {[key: string]: string | string[] | null | undefined} = {},
+    ) => {
       if (telemetryEnabled) {
         logTelemetry(basePath, action, metadata);
       }
diff --git a/js_modules/dagster-ui/packages/ui-core/src/graphql/schema.graphql b/js_modules/dagster-ui/packages/ui-core/src/graphql/schema.graphql
index d1e4a9358235c..2a3510755f6dc 100644
--- a/js_modules/dagster-ui/packages/ui-core/src/graphql/schema.graphql
+++ b/js_modules/dagster-ui/packages/ui-core/src/graphql/schema.graphql
@@ -1511,6 +1511,10 @@ type LaunchRunMutation {
   Output: LaunchRunResult!
 }
 
+type LaunchMultipleRunsMutation {
+  Output: LaunchMultipleRunsResult!
+}
+
 type LaunchRunReexecutionMutation {
   Output: LaunchRunReexecutionResult!
 }
@@ -2982,6 +2986,21 @@ union LaunchRunResult =
   | ConflictingExecutionParamsError
   | NoModeProvidedError
 
+union LaunchMultipleRunsResult =
+  | LaunchMultipleRunsSuccess
+  | InvalidStepError
+  | InvalidOutputError
+  | RunConfigValidationInvalid
+  | PipelineNotFoundError
+  | RunConflict
+  | UnauthorizedError
+  | PythonError
+  | InvalidSubsetError
+  | PresetNotFoundError
+  | ConflictingExecutionParamsError
+  | NoModeProvidedError
+}
+
 union LaunchRunReexecutionResult =
   | LaunchRunSuccess
   | InvalidStepError
@@ -3004,6 +3023,10 @@ type LaunchRunSuccess implements LaunchPipelineRunSuccess {
   run: Run!
 }
 
+type LaunchMultipleRunsSuccess {
+  runs: [LaunchRunSuccess!]!
+}
+
 union RunsOrError = Runs | InvalidPipelineRunsFilterError | PythonError
 
 type Runs implements PipelineRuns {
@@ -3693,6 +3716,7 @@ type AutomationConditionEvaluationNode {
 type Mutation {
   launchPipelineExecution(executionParams: ExecutionParams!): LaunchRunResult!
   launchRun(executionParams: ExecutionParams!): LaunchRunResult!
+  launchMultipleRuns(executionParamsList: [ExecutionParams!]!): LaunchMultipleRunsResult!
   launchPipelineReexecution(
     executionParams: ExecutionParams
     reexecutionParams: ReexecutionParams
diff --git a/js_modules/dagster-ui/packages/ui-core/src/graphql/types.ts b/js_modules/dagster-ui/packages/ui-core/src/graphql/types.ts
index 6f523f80c5fa0..b5a1da6f5f3f9 100644
--- a/js_modules/dagster-ui/packages/ui-core/src/graphql/types.ts
+++ b/js_modules/dagster-ui/packages/ui-core/src/graphql/types.ts
@@ -2211,11 +2211,20 @@ export type LaunchPipelineRunSuccess = {
   run: Run;
 };
 
+export type LaunchMultipleRunsSuccess = {
+  runs: Array<LaunchRunSuccess>;
+};
+
 export type LaunchRunMutation = {
   __typename: 'LaunchRunMutation';
   Output: LaunchRunResult;
 };
 
+export type LaunchMultipleRunsMutation = {
+  __typename: 'LaunchMultipleRunsMutation';
+  Output: LaunchMultipleRunsResult;
+};
+
 export type LaunchRunReexecutionMutation = {
   __typename: 'LaunchRunReexecutionMutation';
   Output: LaunchRunReexecutionResult;
@@ -2249,6 +2258,20 @@ export type LaunchRunResult =
   | RunConflict
   | UnauthorizedError;
 
+export type LaunchMultipleRunsResult =
+  | ConflictingExecutionParamsError
+  | InvalidOutputError
+  | InvalidStepError
+  | InvalidSubsetError
+  | LaunchMultipleRunsSuccess
+  | NoModeProvidedError
+  | PipelineNotFoundError
+  | PresetNotFoundError
+  | PythonError
+  | RunConfigValidationInvalid
+  | RunConflict
+  | UnauthorizedError;
+
 export type LaunchRunSuccess = LaunchPipelineRunSuccess & {
   __typename: 'LaunchRunSuccess';
   run: Run;
@@ -2619,6 +2642,7 @@ export type Mutation = {
   launchPipelineExecution: LaunchRunResult;
   launchPipelineReexecution: LaunchRunReexecutionResult;
   launchRun: LaunchRunResult;
+  launchMultipleRuns: LaunchMultipleRunsResult;
   launchRunReexecution: LaunchRunReexecutionResult;
   logTelemetry: LogTelemetryMutationResult;
   reexecutePartitionBackfill: LaunchBackfillResult;
@@ -2699,6 +2723,10 @@ export type MutationLaunchRunArgs = {
   executionParams: ExecutionParams;
 };
 
+export type MutationLaunchMultipleRunsArgs = {
+  executionParamsList: Array<ExecutionParams>;
+};
+
 export type MutationLaunchRunReexecutionArgs = {
   executionParams?: InputMaybe<ExecutionParams>;
   reexecutionParams?: InputMaybe<ReexecutionParams>;
@@ -9453,6 +9481,23 @@ export const buildLaunchRunMutation = (
   };
 };
 
+export const buildLaunchMultipleRunsMutation = (
+  overrides?: Partial<LaunchMultipleRunsMutation>,
+  _relationshipsToOmit: Set<string> = new Set(),
+): {__typename: 'LaunchMultipleRunsMutation'} & LaunchMultipleRunsMutation => {
+  const relationshipsToOmit: Set<string> = new Set(_relationshipsToOmit);
+  relationshipsToOmit.add('LaunchMultipleRunsMutation');
+  return {
+    __typename: 'LaunchMultipleRunsMutation',
+    Output:
+      overrides && overrides.hasOwnProperty('Output')
+        ? overrides.Output!
+        : relationshipsToOmit.has('ConflictingExecutionParamsError')
+          ? ({} as ConflictingExecutionParamsError)
+          : buildConflictingExecutionParamsError({}, relationshipsToOmit),
+  };
+};
+
 export const buildLaunchRunReexecutionMutation = (
   overrides?: Partial<LaunchRunReexecutionMutation>,
   _relationshipsToOmit: Set<string> = new Set(),
@@ -10224,6 +10269,12 @@ export const buildMutation = (
         : relationshipsToOmit.has('ConflictingExecutionParamsError')
           ? ({} as ConflictingExecutionParamsError)
           : buildConflictingExecutionParamsError({}, relationshipsToOmit),
+    launchMultipleRuns:
+      overrides && overrides.hasOwnProperty('launchMultipleRuns')
+        ? overrides.launchMultipleRuns!
+        : relationshipsToOmit.has('ConflictingExecutionParamsError')
+          ? ({} as ConflictingExecutionParamsError)
+          : buildConflictingExecutionParamsError({}, relationshipsToOmit),
     launchRunReexecution:
       overrides && overrides.hasOwnProperty('launchRunReexecution')
         ? overrides.launchRunReexecution!
diff --git a/js_modules/dagster-ui/packages/ui-core/src/launchpad/useLaunchMultipleRunsWithTelemetry.oss.tsx b/js_modules/dagster-ui/packages/ui-core/src/launchpad/useLaunchMultipleRunsWithTelemetry.oss.tsx
new file mode 100644
index 0000000000000..05a7228e1a771
--- /dev/null
+++ b/js_modules/dagster-ui/packages/ui-core/src/launchpad/useLaunchMultipleRunsWithTelemetry.oss.tsx
@@ -0,0 +1,62 @@
+import {useCallback} from 'react';
+import {useHistory} from 'react-router-dom';
+
+import {useMutation} from '../apollo-client';
+import {TelemetryAction, useTelemetryAction} from '../app/Telemetry';
+import {showLaunchError} from '../launchpad/showLaunchError';
+import {
+  LAUNCH_MULTIPLE_RUNS_MUTATION,
+  LaunchBehavior,
+  handleLaunchMultipleResult,
+} from '../runs/RunUtils';
+import {
+  LaunchMultipleRunsMutation,
+  LaunchMultipleRunsMutationVariables,
+} from '../runs/types/RunUtils.types';
+
+export function useLaunchMultipleRunsWithTelemetry() {
+  const [launchMultipleRuns] = useMutation<
+    LaunchMultipleRunsMutation,
+    LaunchMultipleRunsMutationVariables
+  >(LAUNCH_MULTIPLE_RUNS_MUTATION);
+
+  const logTelemetry = useTelemetryAction();
+  const history = useHistory();
+
+  return useCallback(
+    async (variables: LaunchMultipleRunsMutationVariables, behavior: LaunchBehavior) => {
+      const jobNames = variables.executionParamsList.map((params) => params.selector?.jobName);
+
+      if (
+        jobNames.length !== variables.executionParamsList.length ||
+        jobNames.includes(undefined)
+      ) {
+        return;
+      }
+
+      const metadata: {[key: string]: string | string[] | null | undefined} = {
+        jobNames: jobNames.filter((name): name is string => name !== undefined),
+        opSelection: undefined,
+      };
+
+      let result;
+      try {
+        result = (await launchMultipleRuns({variables})).data?.launchMultipleRuns;
+        if (result) {
+          handleLaunchMultipleResult(result, history, {behavior});
+          logTelemetry(
+            TelemetryAction.LAUNCH_MULTIPLE_RUNS,
+            metadata as {[key: string]: string | string[] | null | undefined},
+          );
+        }
+
+        return result;
+      } catch (error) {
+        console.error('error', error);
+        showLaunchError(error as Error);
+      }
+      return undefined;
+    },
+    [history, launchMultipleRuns, logTelemetry],
+  );
+}
diff --git a/js_modules/dagster-ui/packages/ui-core/src/runs/RunUtils.tsx b/js_modules/dagster-ui/packages/ui-core/src/runs/RunUtils.tsx
index 0c8115d91aa30..4c13f413d45cc 100644
--- a/js_modules/dagster-ui/packages/ui-core/src/runs/RunUtils.tsx
+++ b/js_modules/dagster-ui/packages/ui-core/src/runs/RunUtils.tsx
@@ -7,7 +7,11 @@ import {StepSelection} from './StepSelection';
 import {TimeElapsed} from './TimeElapsed';
 import {RunFragment} from './types/RunFragments.types';
 import {RunTableRunFragment} from './types/RunTableRunFragment.types';
-import {LaunchPipelineExecutionMutation, RunTimeFragment} from './types/RunUtils.types';
+import {
+  LaunchMultipleRunsMutation,
+  LaunchPipelineExecutionMutation,
+  RunTimeFragment,
+} from './types/RunUtils.types';
 import {Mono} from '../../../ui-components/src';
 import {gql} from '../apollo-client';
 import {showCustomAlert} from '../app/CustomAlertProvider';
@@ -115,6 +119,73 @@ export async function handleLaunchResult(
   }
 }
 
+export async function handleLaunchMultipleResult(
+  result: void | null | LaunchMultipleRunsMutation['launchMultipleRuns'],
+  history: History<unknown>,
+  options: {behavior: LaunchBehavior; preserveQuerystring?: boolean},
+) {
+  if (!result) {
+    showCustomAlert({body: `No data was returned. Did dagster-webserver crash?`});
+    return;
+  }
+  const successfulRunIds: string[] = [];
+
+  // show corresponding toasts
+  if (result.__typename === 'LaunchMultipleRunsSuccess') {
+    for (const individualResult of result.runs) {
+      successfulRunIds.push(individualResult.run.id);
+
+      const pathname = `/runs/${individualResult.run.id}`;
+      const search = options.preserveQuerystring ? history.location.search : '';
+      const openInSameTab = () => history.push({pathname, search});
+
+      // using open with multiple runs will spam new tabs
+      if (options.behavior === 'open') {
+        openInSameTab();
+      } else {
+        // toast is more preferred
+        await showSharedToaster({
+          intent: 'success',
+          message: (
+            <div>
+              Launched run <Mono>{individualResult.run.id.slice(0, 8)}</Mono>
+            </div>
+          ),
+          action: {
+            text: 'View',
+            href: history.createHref({pathname, search}),
+          },
+        });
+      }
+      document.dispatchEvent(new CustomEvent('run-launched'));
+    }
+  } else if (result.__typename === 'InvalidSubsetError') {
+    showCustomAlert({body: result.message});
+  } else if (result.__typename === 'PythonError') {
+    showCustomAlert({
+      title: 'Error',
+      body: <PythonErrorInfo error={result} />,
+    });
+  } else {
+    let message = `This multiple job launch cannot be executed with the provided config.`;
+
+    if ('errors' in result) {
+      message += ` Please fix the following errors:\n\n${result.errors
+        .map((error) => error.message)
+        .join('\n\n')}`;
+    }
+
+    showCustomAlert({body: message});
+  }
+
+  // link to runs page filtered to run IDs
+  const params = new URLSearchParams();
+  successfulRunIds.forEach((id) => params.append('q[]', `id:${id}`));
+
+  const queryString = `/runs?${params.toString()}`;
+  history.push(queryString);
+}
+
 function getBaseExecutionMetadata(run: RunFragment | RunTableRunFragment) {
   const hiddenTagKeys: string[] = [DagsterTag.IsResumeRetry, DagsterTag.StepSelection];
 
@@ -204,6 +275,37 @@ export const LAUNCH_PIPELINE_EXECUTION_MUTATION = gql`
   ${PYTHON_ERROR_FRAGMENT}
 `;
 
+export const LAUNCH_MULTIPLE_RUNS_MUTATION = gql`
+  mutation LaunchMultipleRuns($executionParamsList: [ExecutionParams!]!) {
+    launchMultipleRuns(executionParamsList: $executionParamsList) {
+      ... on LaunchMultipleRunsSuccess {
+        runs {
+          ... on LaunchRunSuccess {
+            run {
+              id
+              jobName
+            }
+          }
+        }
+      }
+      ... on PipelineNotFoundError {
+        message
+      }
+      ... on InvalidSubsetError {
+        message
+      }
+      ... on RunConfigValidationInvalid {
+        errors {
+          message
+        }
+      }
+      ...PythonErrorFragment
+    }
+  }
+
+  ${PYTHON_ERROR_FRAGMENT}
+`;
+
 export const DELETE_MUTATION = gql`
   mutation Delete($runId: String!) {
     deletePipelineRun(runId: $runId) {
diff --git a/js_modules/dagster-ui/packages/ui-core/src/runs/types/RunUtils.types.ts b/js_modules/dagster-ui/packages/ui-core/src/runs/types/RunUtils.types.ts
index f9dbe944212ae..46feb4e0249e1 100644
--- a/js_modules/dagster-ui/packages/ui-core/src/runs/types/RunUtils.types.ts
+++ b/js_modules/dagster-ui/packages/ui-core/src/runs/types/RunUtils.types.ts
@@ -42,6 +42,55 @@ export type LaunchPipelineExecutionMutation = {
     | {__typename: 'UnauthorizedError'};
 };
 
+export type LaunchMultipleRunsMutationVariables = Types.Exact<{
+  executionParamsList: Array<Types.ExecutionParams>;
+}>;
+
+export type LaunchMultipleRunsMutation = {
+  __typename: 'Mutation';
+  launchMultipleRuns:
+    | {__typename: 'ConflictingExecutionParamsError'}
+    | {__typename: 'InvalidOutputError'}
+    | {__typename: 'InvalidStepError'}
+    | {__typename: 'InvalidSubsetError'; message: string}
+    | {
+        __typename: 'LaunchMultipleRunsSuccess';
+        runs: Array<{
+          __typename: 'LaunchRunSuccess';
+          run: {
+            id: string;
+            jobName: string;
+          };
+        }>;
+      }
+    | {__typename: 'NoModeProvidedError'}
+    | {__typename: 'PipelineNotFoundError'; message: string}
+    | {__typename: 'PresetNotFoundError'}
+    | {
+        __typename: 'PythonError';
+        message: string;
+        stack: Array<string>;
+        errorChain: Array<{
+          __typename: 'ErrorChainLink';
+          isExplicitLink: boolean;
+          error: {__typename: 'PythonError'; message: string; stack: Array<string>};
+        }>;
+      }
+    | {
+        __typename: 'RunConfigValidationInvalid';
+        errors: Array<
+          | {__typename: 'FieldNotDefinedConfigError'; message: string}
+          | {__typename: 'FieldsNotDefinedConfigError'; message: string}
+          | {__typename: 'MissingFieldConfigError'; message: string}
+          | {__typename: 'MissingFieldsConfigError'; message: string}
+          | {__typename: 'RuntimeMismatchConfigError'; message: string}
+          | {__typename: 'SelectorTypeConfigError'; message: string}
+        >;
+      }
+    | {__typename: 'RunConflict'}
+    | {__typename: 'UnauthorizedError'};
+};
+
 export type DeleteMutationVariables = Types.Exact<{
   runId: Types.Scalars['String']['input'];
 }>;
@@ -166,10 +215,12 @@ export type RunTimeFragment = {
   updateTime: number | null;
 };
 
-export const LaunchPipelineExecutionVersion = '292088c4a697aca6be1d3bbc0cfc45d8a13cdb2e75cfedc64b68c6245ea34f89';
+export const LaunchPipelineExecutionVersion =
+  '292088c4a697aca6be1d3bbc0cfc45d8a13cdb2e75cfedc64b68c6245ea34f89';
 
 export const DeleteVersion = '3c61c79b99122910e754a8863e80dc5ed479a0c23cc1a9d9878d91e603fc0dfe';
 
 export const TerminateVersion = '67acf403eb320a93c9a9aa07f675a1557e0887d499cd5598f1d5ff360afc15c0';
 
-export const LaunchPipelineReexecutionVersion = 'd21e4ecaf3d1d163c4772f1d847dbdcbdaa9a40e6de0808a064ae767adf0c311';
+export const LaunchPipelineReexecutionVersion =
+  'd21e4ecaf3d1d163c4772f1d847dbdcbdaa9a40e6de0808a064ae767adf0c311';
diff --git a/js_modules/dagster-ui/packages/ui-core/src/ticks/SensorDryRunDialog.tsx b/js_modules/dagster-ui/packages/ui-core/src/ticks/SensorDryRunDialog.tsx
index 0af78ed4cea37..190f169ef09aa 100644
--- a/js_modules/dagster-ui/packages/ui-core/src/ticks/SensorDryRunDialog.tsx
+++ b/js_modules/dagster-ui/packages/ui-core/src/ticks/SensorDryRunDialog.tsx
@@ -13,15 +13,18 @@ import {
   Subheading,
   Tag,
   TextInput,
+  Tooltip,
 } from '@dagster-io/ui-components';
 import {useCallback, useMemo, useState} from 'react';
+import {useLaunchMultipleRunsWithTelemetry} from 'shared/launchpad/useLaunchMultipleRunsWithTelemetry.oss';
 import styled from 'styled-components';
 
 import {RunRequestTable} from './DryRunRequestTable';
 import {DynamicPartitionRequests} from './DynamicPartitionRequests';
-import {RUN_REQUEST_FRAGMENT} from './RunRequestFragment';
 import {gql, useMutation} from '../apollo-client';
+import {RUN_REQUEST_FRAGMENT} from './RunRequestFragment';
 import {
+  SensorDryRunInstigationTick,
   SensorDryRunMutation,
   SensorDryRunMutationVariables,
 } from './types/SensorDryRunDialog.types';
@@ -31,19 +34,16 @@ import {PYTHON_ERROR_FRAGMENT} from '../app/PythonErrorFragment';
 import {PythonErrorInfo} from '../app/PythonErrorInfo';
 import {assertUnreachable} from '../app/Util';
 import {PythonErrorFragment} from '../app/types/PythonErrorFragment.types';
+import {ExecutionParams, SensorSelector} from '../graphql/types';
 import {SET_CURSOR_MUTATION} from '../sensors/EditCursorDialog';
 import {
   SetSensorCursorMutation,
   SetSensorCursorMutationVariables,
 } from '../sensors/types/EditCursorDialog.types';
 import {testId} from '../testing/testId';
+import {buildExecutionParamsListSensor} from '../util/buildExecutionParamsList';
 import {RepoAddress} from '../workspace/types';
 
-type DryRunInstigationTick = Extract<
-  SensorDryRunMutation['sensorDryRun'],
-  {__typename: 'DryRunInstigationTick'}
->;
-
 type Props = {
   name: string;
   onClose: () => void;
@@ -76,12 +76,13 @@ const SensorDryRun = ({repoAddress, name, currentCursor, onClose, jobName}: Prop
   const [cursor, setCursor] = useState(currentCursor);
 
   const [submitting, setSubmitting] = useState(false);
+  const [launching, setLaunching] = useState(false);
   const [error, setError] = useState<PythonErrorFragment | null>(null);
-  const [sensorExecutionData, setSensorExecutionData] = useState<DryRunInstigationTick | null>(
-    null,
-  );
+  const [sensorExecutionData, setSensorExecutionData] =
+    useState<SensorDryRunInstigationTick | null>(null);
+  const [executionParamsList, setExecutionParamsList] = useState<ExecutionParams[]>([]);
 
-  const sensorSelector = useMemo(
+  const sensorSelector: SensorSelector = useMemo(
     () => ({
       sensorName: name,
       repositoryLocationName: repoAddress.location,
@@ -105,6 +106,7 @@ const SensorDryRun = ({repoAddress, name, currentCursor, onClose, jobName}: Prop
           setError(data.evaluationResult.error);
         } else {
           setSensorExecutionData(data);
+          setExecutionParamsList(buildExecutionParamsListSensor(data, sensorSelector));
         }
       } else if (data?.__typename === 'SensorNotFoundError') {
         showCustomAlert({
@@ -120,16 +122,47 @@ const SensorDryRun = ({repoAddress, name, currentCursor, onClose, jobName}: Prop
     setSubmitting(false);
   }, [sensorDryRun, sensorSelector, cursor, name]);
 
+  const launchMultipleRunsWithTelemetry = useLaunchMultipleRunsWithTelemetry();
+
+  const canLaunchAll = useMemo(() => {
+    return executionParamsList != null && executionParamsList.length > 0;
+  }, [executionParamsList]);
+
+  const onLaunchAll = async () => {
+    if (!canLaunchAll) {
+      return;
+    }
+    setLaunching(true);
+
+    await launchMultipleRunsWithTelemetry({executionParamsList}, 'toast');
+
+    setLaunching(false);
+    onClose();
+  };
+
   const buttons = useMemo(() => {
+    if (launching) {
+      return <Box flex={{direction: 'row', gap: 8}}></Box>;
+    }
+
     if (sensorExecutionData || error) {
       return (
         <Box flex={{direction: 'row', gap: 8}}>
-          <Button>Launch all</Button>
+          <Tooltip
+            canShow={!canLaunchAll || launching}
+            content="Preparing to launch runs"
+            placement="top-end"
+          >
+            <Button disabled={!canLaunchAll || launching} onClick={onLaunchAll}>
+              <div>Launch all</div>
+            </Button>
+          </Tooltip>
           <Button
             data-testid={testId('test-again')}
             onClick={() => {
               setSensorExecutionData(null);
               setError(null);
+              setExecutionParamsList([]);
             }}
           >
             Test again
@@ -156,7 +189,9 @@ const SensorDryRun = ({repoAddress, name, currentCursor, onClose, jobName}: Prop
         </Box>
       );
     }
-  }, [sensorExecutionData, error, submitting, onClose, submitTest]);
+
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [sensorExecutionData, error, submitting, launching, onClose, submitTest, canLaunchAll]);
 
   const [cursorState, setCursorState] = useState<'Unpersisted' | 'Persisting' | 'Persisted'>(
     'Unpersisted',
@@ -209,6 +244,14 @@ const SensorDryRun = ({repoAddress, name, currentCursor, onClose, jobName}: Prop
   }, [sensorExecutionData?.evaluationResult?.cursor, sensorSelector, setCursorMutation]);
 
   const content = useMemo(() => {
+    if (launching) {
+      return (
+        <Box flex={{direction: 'row', gap: 8, justifyContent: 'center', alignItems: 'center'}}>
+          <Spinner purpose="body-text" />
+          <div>Launching runs</div>
+        </Box>
+      );
+    }
     if (sensorExecutionData || error) {
       const runRequests = sensorExecutionData?.evaluationResult?.runRequests;
       const numRunRequests = runRequests?.length || 0;
@@ -341,6 +384,7 @@ const SensorDryRun = ({repoAddress, name, currentCursor, onClose, jobName}: Prop
     sensorExecutionData,
     error,
     submitting,
+    launching,
     currentCursor,
     cursorState,
     onPersistCursorValue,
diff --git a/js_modules/dagster-ui/packages/ui-core/src/ticks/types/SensorDryRunDialog.types.ts b/js_modules/dagster-ui/packages/ui-core/src/ticks/types/SensorDryRunDialog.types.ts
index da349829a463f..da014951e94dc 100644
--- a/js_modules/dagster-ui/packages/ui-core/src/ticks/types/SensorDryRunDialog.types.ts
+++ b/js_modules/dagster-ui/packages/ui-core/src/ticks/types/SensorDryRunDialog.types.ts
@@ -2,6 +2,11 @@
 
 import * as Types from '../../graphql/types';
 
+export type SensorDryRunInstigationTick = Extract<
+  SensorDryRunMutation['sensorDryRun'],
+  {__typename: 'DryRunInstigationTick'}
+>;
+
 export type SensorDryRunMutationVariables = Types.Exact<{
   selectorData: Types.SensorSelector;
   cursor?: Types.InputMaybe<Types.Scalars['String']['input']>;
@@ -63,4 +68,5 @@ export type DynamicPartitionRequestFragment = {
   type: Types.DynamicPartitionsRequestType;
 };
 
-export const SensorDryRunMutationVersion = '018c498063838a146dbc76607bc84c92c235eaa73a3859b1c94b469bc76f5170';
+export const SensorDryRunMutationVersion =
+  '018c498063838a146dbc76607bc84c92c235eaa73a3859b1c94b469bc76f5170';
diff --git a/js_modules/dagster-ui/packages/ui-core/src/util/buildExecutionParamsList.ts b/js_modules/dagster-ui/packages/ui-core/src/util/buildExecutionParamsList.ts
new file mode 100644
index 0000000000000..00c997832858f
--- /dev/null
+++ b/js_modules/dagster-ui/packages/ui-core/src/util/buildExecutionParamsList.ts
@@ -0,0 +1,53 @@
+import * as yaml from 'yaml';
+
+import {showCustomAlert} from '../app/CustomAlertProvider';
+import {ExecutionParams, SensorSelector} from '../graphql/types';
+import {sanitizeConfigYamlString} from '../launchpad/yamlUtils';
+import {SensorDryRunInstigationTick} from '../ticks/types/SensorDryRunDialog.types';
+
+const YAML_SYNTAX_INVALID = `The YAML you provided couldn't be parsed. Please fix the syntax errors and try again.`;
+
+// This helper removes __typename, which prevents tags from being passed back to GraphQL
+const onlyKeyAndValue = ({key, value}: {key: string; value: string}) => ({key, value});
+
+// adapted from buildExecutionVariables() in LaunchpadSession.tsx
+export const buildExecutionParamsListSensor = (
+  sensorExecutionData: SensorDryRunInstigationTick,
+  sensorSelector: SensorSelector,
+) => {
+  if (!sensorExecutionData) {
+    return [];
+  }
+
+  const executionParamsList: ExecutionParams[] = [];
+
+  sensorExecutionData?.evaluationResult?.runRequests?.forEach((request) => {
+    const configYamlOrEmpty = sanitizeConfigYamlString(request.runConfigYaml);
+
+    try {
+      yaml.parse(configYamlOrEmpty);
+    } catch {
+      showCustomAlert({title: 'Invalid YAML', body: YAML_SYNTAX_INVALID});
+      return;
+    }
+    const {repositoryLocationName, repositoryName} = sensorSelector;
+
+    const executionParams: ExecutionParams = {
+      runConfigData: configYamlOrEmpty,
+      selector: {
+        jobName: request.jobName, // get jobName from runRequest
+        repositoryLocationName,
+        repositoryName,
+        assetSelection: [],
+        assetCheckSelection: [],
+        solidSelection: undefined,
+      },
+      mode: 'default',
+      executionMetadata: {
+        tags: [...request.tags.map(onlyKeyAndValue)],
+      },
+    };
+    executionParamsList.push(executionParams);
+  });
+  return executionParamsList;
+};
diff --git a/python_modules/dagster-graphql/dagster_graphql/client/query.py b/python_modules/dagster-graphql/dagster_graphql/client/query.py
index 579b4e6e7a046..6754ee91ab139 100644
--- a/python_modules/dagster-graphql/dagster_graphql/client/query.py
+++ b/python_modules/dagster-graphql/dagster_graphql/client/query.py
@@ -330,6 +330,74 @@
 )
 
 
+LAUNCH_MULTIPLE_RUNS_MUTATION = (
+    ERROR_FRAGMENT
+    + """
+mutation($executionParamsList: [ExecutionParams!]!) {
+  launchMultipleRuns(executionParamsList: $executionParamsList) {
+    __typename
+    
+    ... on InvalidStepError {
+      invalidStepKey
+    }
+    ... on InvalidOutputError {
+      stepKey
+      invalidOutputName
+    }
+    ... on LaunchMultipleRunsSuccess {
+      runs {
+        ... on LaunchRunSuccess {
+          __typename
+          run {
+            runId
+            pipeline {
+              name
+            }
+            tags {
+              key
+              value
+            }
+            status
+            runConfigYaml
+            mode
+            resolvedOpSelection
+          }
+        }
+      }
+    }
+    ... on ConflictingExecutionParamsError {
+      message
+    }
+    ... on PresetNotFoundError {
+      preset
+      message
+    }
+    ... on RunConfigValidationInvalid {
+      pipelineName
+      errors {
+        __typename
+        message
+        path
+        reason
+      }
+    }
+    ... on PipelineNotFoundError {
+      message
+      pipelineName
+    }
+
+    ... on UnauthorizedError {
+      message
+    }
+    
+    ... on PythonError {
+      ...errorFragment
+    }
+  }
+}
+"""
+)
+
 LAUNCH_PIPELINE_REEXECUTION_MUTATION = (
     ERROR_FRAGMENT
     + """
diff --git a/python_modules/dagster-graphql/dagster_graphql/schema/roots/__init__.py b/python_modules/dagster-graphql/dagster_graphql/schema/roots/__init__.py
index 6533d2d0b0f32..10f029145bc11 100644
--- a/python_modules/dagster-graphql/dagster_graphql/schema/roots/__init__.py
+++ b/python_modules/dagster-graphql/dagster_graphql/schema/roots/__init__.py
@@ -10,6 +10,7 @@ def types():
         GrapheneDeletePipelineRunSuccess,
         GrapheneDeleteRunMutation,
         GrapheneLaunchBackfillMutation,
+        GrapheneLaunchMultipleRunsMutation,
         GrapheneLaunchRunMutation,
         GrapheneLaunchRunReexecutionMutation,
         GrapheneReloadRepositoryLocationMutation,
@@ -38,6 +39,7 @@ def types():
         GrapheneExecutionPlanOrError,
         GrapheneLaunchBackfillMutation,
         GrapheneLaunchRunMutation,
+        GrapheneLaunchMultipleRunsMutation,
         GrapheneLaunchRunReexecutionMutation,
         GraphenePipelineOrError,
         GrapheneReloadRepositoryLocationMutation,
diff --git a/python_modules/dagster-graphql/dagster_graphql/schema/roots/mutation.py b/python_modules/dagster-graphql/dagster_graphql/schema/roots/mutation.py
index 0e98ceda547ee..f921676a2046d 100644
--- a/python_modules/dagster-graphql/dagster_graphql/schema/roots/mutation.py
+++ b/python_modules/dagster-graphql/dagster_graphql/schema/roots/mutation.py
@@ -1,4 +1,4 @@
-from typing import Optional, Sequence, Union
+from typing import List, Optional, Sequence, Union
 
 import dagster._check as check
 import graphene
@@ -78,6 +78,8 @@
 )
 from dagster_graphql.schema.pipelines.pipeline import GrapheneRun
 from dagster_graphql.schema.runs import (
+    GrapheneLaunchMultipleRunsResult,
+    GrapheneLaunchMultipleRunsSuccess,
     GrapheneLaunchRunReexecutionResult,
     GrapheneLaunchRunResult,
     GrapheneLaunchRunSuccess,
@@ -316,6 +318,34 @@ def mutate(
         return create_execution_params_and_launch_pipeline_exec(graphene_info, executionParams)
 
 
+class GrapheneLaunchMultipleRunsMutation(graphene.Mutation):
+    """Launches multiple job runs."""
+
+    Output = graphene.NonNull(GrapheneLaunchMultipleRunsResult)
+
+    class Arguments:
+        executionParamsList = graphene.List(graphene.NonNull(GrapheneExecutionParams))
+
+    class Meta:
+        name = "LaunchMultipleRunsMutation"
+
+    @capture_error
+    @require_permission_check(Permissions.LAUNCH_PIPELINE_EXECUTION)
+    def mutate(
+        self, graphene_info: ResolveInfo, executionParamsList: List[GrapheneExecutionParams]
+    ) -> Union[GrapheneLaunchMultipleRunsSuccess, GrapheneError, GraphenePythonError]:
+        results = []
+        for execution_params in executionParamsList:
+            try:
+                result = create_execution_params_and_launch_pipeline_exec(
+                    graphene_info, execution_params
+                )
+                results.append(result)
+            except Exception as e:
+                return GraphenePythonError(error_info=e)
+        return GrapheneLaunchMultipleRunsSuccess(runs=results)
+
+
 class GrapheneLaunchBackfillMutation(graphene.Mutation):
     """Launches a set of partition backfill runs."""
 
@@ -984,6 +1014,7 @@ class Meta:
 
     launchPipelineExecution = GrapheneLaunchRunMutation.Field()
     launchRun = GrapheneLaunchRunMutation.Field()
+    launchMultipleRuns = GrapheneLaunchMultipleRunsMutation.Field()
     launchPipelineReexecution = GrapheneLaunchRunReexecutionMutation.Field()
     launchRunReexecution = GrapheneLaunchRunReexecutionMutation.Field()
     startSchedule = GrapheneStartScheduleMutation.Field()
diff --git a/python_modules/dagster-graphql/dagster_graphql/schema/runs.py b/python_modules/dagster-graphql/dagster_graphql/schema/runs.py
index 9aabe08512373..be3b92a36c218 100644
--- a/python_modules/dagster-graphql/dagster_graphql/schema/runs.py
+++ b/python_modules/dagster-graphql/dagster_graphql/schema/runs.py
@@ -11,6 +11,7 @@
 
 from dagster_graphql.implementation.fetch_runs import get_run_ids, get_runs, get_runs_count
 from dagster_graphql.implementation.utils import UserFacingGraphQLError
+from dagster_graphql.schema.backfill import pipeline_execution_error_types
 from dagster_graphql.schema.errors import (
     GrapheneInvalidPipelineRunsFilterError,
     GraphenePythonError,
@@ -45,6 +46,13 @@ class Meta:
         name = "LaunchRunSuccess"
 
 
+class GrapheneLaunchMultipleRunsSuccess(graphene.ObjectType):
+    runs = graphene.List(GrapheneLaunchRunSuccess)
+
+    class Meta:
+        name = "LaunchMultipleRunsSuccess"
+
+
 class GrapheneRunGroup(graphene.ObjectType):
     rootRunId = graphene.NonNull(graphene.String)
     runs = graphene.List("dagster_graphql.schema.pipelines.pipeline.GrapheneRun")
@@ -69,21 +77,26 @@ class Meta:
 
 
 launch_pipeline_run_result_types = (GrapheneLaunchRunSuccess,)
+launch_multiple_runs_result_types = (GrapheneLaunchMultipleRunsSuccess,)
 
 
 class GrapheneLaunchRunResult(graphene.Union):
     class Meta:
-        from dagster_graphql.schema.backfill import pipeline_execution_error_types
-
         types = launch_pipeline_run_result_types + pipeline_execution_error_types
 
         name = "LaunchRunResult"
 
 
-class GrapheneLaunchRunReexecutionResult(graphene.Union):
+class GrapheneLaunchMultipleRunsResult(graphene.Union):
+    """Contains results from multiple pipeline launches."""
+
     class Meta:
-        from dagster_graphql.schema.backfill import pipeline_execution_error_types
+        types = launch_multiple_runs_result_types + pipeline_execution_error_types
+        name = "LaunchMultipleRunsResult"
+
 
+class GrapheneLaunchRunReexecutionResult(graphene.Union):
+    class Meta:
         types = launch_pipeline_run_result_types + pipeline_execution_error_types
 
         name = "LaunchRunReexecutionResult"
@@ -213,6 +226,7 @@ def parse_run_config_input(
 
 types = [
     GrapheneLaunchRunResult,
+    GrapheneLaunchMultipleRunsResult,
     GrapheneLaunchRunReexecutionResult,
     GrapheneLaunchPipelineRunSuccess,
     GrapheneLaunchRunSuccess,
diff --git a/python_modules/dagster-graphql/dagster_graphql_tests/graphql/test_run_launcher.py b/python_modules/dagster-graphql/dagster_graphql_tests/graphql/test_run_launcher.py
index f33fc6139d7e7..a82d4bc74c289 100644
--- a/python_modules/dagster-graphql/dagster_graphql_tests/graphql/test_run_launcher.py
+++ b/python_modules/dagster-graphql/dagster_graphql_tests/graphql/test_run_launcher.py
@@ -1,8 +1,12 @@
 from typing import Any
+from unittest.mock import patch
 
 from dagster._core.test_utils import wait_for_runs_to_finish
 from dagster._core.workspace.context import WorkspaceRequestContext
-from dagster_graphql.client.query import LAUNCH_PIPELINE_EXECUTION_MUTATION
+from dagster_graphql.client.query import (
+    LAUNCH_MULTIPLE_RUNS_MUTATION,
+    LAUNCH_PIPELINE_EXECUTION_MUTATION,
+)
 from dagster_graphql.test.utils import execute_dagster_graphql, infer_job_selector
 
 from dagster_graphql_tests.graphql.graphql_context_test_suite import (
@@ -32,6 +36,12 @@
 BaseTestSuite: Any = make_graphql_context_test_suite(
     context_variants=GraphQLContextVariant.all_executing_variants()
 )
+LaunchFailTestSuite: Any = make_graphql_context_test_suite(
+    context_variants=GraphQLContextVariant.all_non_launchable_variants()
+)
+ReadOnlyTestSuite: Any = make_graphql_context_test_suite(
+    context_variants=GraphQLContextVariant.all_readonly_variants()
+)
 
 
 class TestBasicLaunch(BaseTestSuite):
@@ -84,9 +94,104 @@ def test_run_launcher_subset(self, graphql_context: WorkspaceRequestContext):
         assert result.data["pipelineRunOrError"]["stats"]["stepsSucceeded"] == 1
 
 
-LaunchFailTestSuite: Any = make_graphql_context_test_suite(
-    context_variants=GraphQLContextVariant.all_non_launchable_variants()
-)
+class TestMultipleLaunch(BaseTestSuite):
+    def test_multiple_run_launcher_same_job(self, graphql_context: WorkspaceRequestContext):
+        selector = infer_job_selector(graphql_context, "no_config_job")
+
+        # test with multiple of the same job
+        executionParamsList = [
+            {"selector": selector, "mode": "default"},
+            {"selector": selector, "mode": "default"},
+            {"selector": selector, "mode": "default"},
+        ]
+
+        result = execute_dagster_graphql(
+            context=graphql_context,
+            query=LAUNCH_MULTIPLE_RUNS_MUTATION,
+            variables={"executionParamsList": executionParamsList},
+        )
+
+        assert "launchMultipleRuns" in result.data
+        launches = result.data["launchMultipleRuns"]
+        assert launches["__typename"] == "LaunchMultipleRunsSuccess"
+
+        run_ids = []
+        runs = launches.get("runs", [])
+
+        for run in runs:
+            assert run["__typename"] == "LaunchRunSuccess"
+            run_ids.append(run["run"]["runId"])
+
+        wait_for_runs_to_finish(graphql_context.instance)
+
+        for run_id in run_ids:
+            result = execute_dagster_graphql(
+                context=graphql_context, query=RUN_QUERY, variables={"runId": run_id}
+            )
+            assert result.data["pipelineRunOrError"]["__typename"] == "Run"
+            assert result.data["pipelineRunOrError"]["status"] == "SUCCESS"
+
+    def test_multiple_run_launcher_multiple_jobs(self, graphql_context: WorkspaceRequestContext):
+        selectors = [
+            infer_job_selector(graphql_context, "no_config_job"),
+            infer_job_selector(graphql_context, "more_complicated_config", ["noop_op"]),
+        ]
+
+        # test with multiple of the same job
+        executionParamsList = [
+            {"selector": selectors[0], "mode": "default"},
+            {"selector": selectors[1], "mode": "default"},
+            {"selector": selectors[0], "mode": "default"},
+            {"selector": selectors[1], "mode": "default"},
+        ]
+
+        result = execute_dagster_graphql(
+            context=graphql_context,
+            query=LAUNCH_MULTIPLE_RUNS_MUTATION,
+            variables={"executionParamsList": executionParamsList},
+        )
+
+        assert "launchMultipleRuns" in result.data
+        launches = result.data["launchMultipleRuns"]
+        assert launches["__typename"] == "LaunchMultipleRunsSuccess"
+
+        run_ids = []
+        runs = launches.get("runs", [])
+
+        for run in runs:
+            assert run["__typename"] == "LaunchRunSuccess"
+            run_ids.append(run["run"]["runId"])
+
+        wait_for_runs_to_finish(graphql_context.instance)
+
+        for run_id in run_ids:
+            result = execute_dagster_graphql(
+                context=graphql_context, query=RUN_QUERY, variables={"runId": run_id}
+            )
+            assert result.data["pipelineRunOrError"]["__typename"] == "Run"
+            assert result.data["pipelineRunOrError"]["status"] == "SUCCESS"
+            if result.data["pipelineRunOrError"].get("stats"):
+                assert result.data["pipelineRunOrError"]["stats"]["stepsSucceeded"] == 1
+
+    def test_multiple_launch_failure_unauthorized(self, graphql_context: WorkspaceRequestContext):
+        executionParamsList = [
+            {"selector": infer_job_selector(graphql_context, "no_config_job"), "mode": "default"},
+            {"selector": infer_job_selector(graphql_context, "no_config_job"), "mode": "default"},
+        ]
+
+        # Mock `has_permission_for_location` to return False
+        with patch.object(graphql_context, "has_permission_for_location", return_value=False):
+            result = execute_dagster_graphql(
+                context=graphql_context,
+                query=LAUNCH_MULTIPLE_RUNS_MUTATION,
+                variables={"executionParamsList": executionParamsList},
+            )
+            assert "launchMultipleRuns" in result.data
+            unauthorized_error = result.data["launchMultipleRuns"]
+
+            assert unauthorized_error["__typename"] == "PythonError"
+            assert "message" in unauthorized_error
+            assert "GrapheneUnauthorizedError" in unauthorized_error["message"]
 
 
 class TestFailedLaunch(LaunchFailTestSuite):
@@ -109,3 +214,50 @@ def test_launch_failure(self, graphql_context: WorkspaceRequestContext):
         assert result.data["pipelineRunOrError"]["status"] == "FAILURE"
         assert result.data["pipelineRunOrError"]["startTime"]
         assert result.data["pipelineRunOrError"]["endTime"]
+
+
+class TestFailedMultipleLaunch(LaunchFailTestSuite):
+    def test_multiple_launch_failure(self, graphql_context: WorkspaceRequestContext):
+        executionParamsList = [
+            {"selector": infer_job_selector(graphql_context, "no_config_job"), "mode": "default"},
+            {"selector": infer_job_selector(graphql_context, "no_config_job"), "mode": "default"},
+        ]
+
+        result = execute_dagster_graphql(
+            context=graphql_context,
+            query=LAUNCH_MULTIPLE_RUNS_MUTATION,
+            variables={"executionParamsList": executionParamsList},
+        )
+
+        assert result.data["launchMultipleRuns"]["__typename"] != "LaunchRunSuccess"
+
+        # fetch the most recent runs
+        run_ids = [run.run_id for run in graphql_context.instance.get_runs(limit=2)]
+
+        for run_id in run_ids:
+            result = execute_dagster_graphql(
+                context=graphql_context, query=RUN_QUERY, variables={"runId": run_id}
+            )
+            assert result.data["pipelineRunOrError"]["__typename"] == "Run"
+            assert result.data["pipelineRunOrError"]["status"] == "FAILURE"
+            assert result.data["pipelineRunOrError"]["startTime"]
+            assert result.data["pipelineRunOrError"]["endTime"]
+
+
+class TestFailedMultipleLaunchReadOnly(ReadOnlyTestSuite):
+    def test_multiple_launch_failure_readonly(self, graphql_context: WorkspaceRequestContext):
+        executionParamsList = [
+            {"selector": infer_job_selector(graphql_context, "no_config_job"), "mode": "default"},
+            {"selector": infer_job_selector(graphql_context, "no_config_job"), "mode": "default"},
+        ]
+
+        result = execute_dagster_graphql(
+            context=graphql_context,
+            query=LAUNCH_MULTIPLE_RUNS_MUTATION,
+            variables={"executionParamsList": executionParamsList},
+        )
+
+        assert result.data["launchMultipleRuns"]["__typename"] != "LaunchMultipleRunsSuccess"
+        assert result.data["launchMultipleRuns"]["__typename"] == "PythonError"
+        assert "message" in result.data["launchMultipleRuns"]
+        assert "GrapheneUnauthorizedError" in result.data["launchMultipleRuns"]["message"]