diff --git a/src/LLL.DurableTask.Ui/app/src/components/ReasonDialog.tsx b/src/LLL.DurableTask.Ui/app/src/components/ReasonDialog.tsx
new file mode 100644
index 0000000..8c09c26
--- /dev/null
+++ b/src/LLL.DurableTask.Ui/app/src/components/ReasonDialog.tsx
@@ -0,0 +1,73 @@
+import {
+  Button,
+  Dialog,
+  DialogActions,
+  DialogContent,
+  DialogContentText,
+  DialogTitle,
+  TextField,
+} from "@mui/material";
+import React, { useState } from "react";
+
+interface ReasonDialogProps {
+  open: boolean;
+  title: string;
+  description: string;
+  onClose: () => void;
+  onConfirm: (reason: string) => void;
+}
+
+export function ReasonDialog({
+  open,
+  title,
+  description,
+  onClose,
+  onConfirm,
+}: ReasonDialogProps) {
+  const [reason, setReason] = useState("");
+
+  const handleConfirm = () => {
+    const value = reason;
+    setReason("");
+    onConfirm(value);
+  };
+
+  const handleClose = () => {
+    setReason("");
+    onClose();
+  };
+
+  return (
+    <Dialog
+      open={open}
+      onClose={handleClose}
+      fullWidth
+      maxWidth="sm"
+      disableRestoreFocus
+    >
+      <DialogTitle>{title}</DialogTitle>
+      <DialogContent>
+        <DialogContentText sx={{ mb: 2 }}>{description}</DialogContentText>
+        <TextField
+          autoFocus
+          label="Reason"
+          fullWidth
+          value={reason}
+          onChange={(e) => setReason(e.target.value)}
+          onKeyDown={(e) => {
+            if (e.key === "Enter") {
+              e.preventDefault();
+              handleConfirm();
+            }
+          }}
+        />
+      </DialogContent>
+      <DialogActions>
+        <Button onClick={handleClose}>Cancel</Button>
+        <Button variant="contained" onClick={handleConfirm}>
+          {title}
+        </Button>
+      </DialogActions>
+    </Dialog>
+  );
+}
diff --git a/src/LLL.DurableTask.Ui/app/src/views/orchestration/Orchestration.tsx b/src/LLL.DurableTask.Ui/app/src/views/orchestration/Orchestration.tsx
index d06ca5f..b36a6b1 100644
--- a/src/LLL.DurableTask.Ui/app/src/views/orchestration/Orchestration.tsx
+++ b/src/LLL.DurableTask.Ui/app/src/views/orchestration/Orchestration.tsx
@@ -1,4 +1,6 @@
 import DeleteIcon from "@mui/icons-material/Delete";
+import ReplayIcon from "@mui/icons-material/Replay";
+import StopIcon from "@mui/icons-material/Stop";
 import { LoadingButton } from "@mui/lab";
 import {
   Box,
@@ -15,9 +17,10 @@ import {
 import { keepPreviousData, useMutation, useQuery } from "@tanstack/react-query";
 import { useConfirm } from "material-ui-confirm";
 import { useSnackbar } from "notistack";
-import React, { useCallback } from "react";
+import React, { useCallback, useState } from "react";
 import { Link as RouterLink, useNavigate, useParams } from "react-router";
 import { ErrorAlert } from "../../components/ErrorAlert";
+import { ReasonDialog } from "../../components/ReasonDialog";
 import { AutoRefreshButton } from "../../components/RefreshButton";
 import { useApiClient } from "../../hooks/useApiClient";
 import { useQueryState } from "../../hooks/useQueryState";
@@ -25,23 +28,14 @@ import { useRefreshInterval } from "../../hooks/useRefreshInterval";
 import { ExecutionsList } from "./ExecutionsList";
 import { HistoryTable } from "./HistoryTable";
 import { RaiseEvent } from "./RaiseEvent";
-import { Rewind } from "./Rewind";
 import { State } from "./State";
-import { Terminate } from "./Terminate";
 
 type RouteParams = {
   instanceId: string;
   executionId: string;
 };
 
-type TabValue =
-  | "state"
-  | "history"
-  | "executions"
-  | "raise_event"
-  | "terminate"
-  | "rewind"
-  | "json";
+type TabValue = "state" | "history" | "executions" | "raise_event" | "json";
 
 export function Orchestration() {
   const [tab, setTab] = useQueryState<TabValue>("tab", "state");
@@ -91,29 +85,29 @@ export function Orchestration() {
     mutationFn: (args) => apiClient.purgeOrchestration(...args),
   });
 
-  const handlePurgeClick = useCallback(() => {
-    confirm({
+  const handlePurgeClick = useCallback(async () => {
+    const { confirmed } = await confirm({
       description:
         "This action is irreversible. Do you confirm the purge of this instance?",
-    }).then(async () => {
-      try {
-        await purgeMutation.mutateAsync([instanceId]);
-        enqueueSnackbar("Instance purged", {
-          variant: "success",
-        });
-        navigate(`/orchestrations`);
-      } catch (error) {
-        enqueueSnackbar(String(error), {
-          variant: "error",
-          persist: true,
-          action: (key) => (
-            <Button color="inherit" onClick={() => closeSnackbar(key)}>
-              Dismiss
-            </Button>
-          ),
-        });
-      }
     });
+    if (!confirmed) return;
+    try {
+      await purgeMutation.mutateAsync([instanceId]);
+      enqueueSnackbar("Instance purged", {
+        variant: "success",
+      });
+      navigate(`/orchestrations`);
+    } catch (error) {
+      enqueueSnackbar(String(error), {
+        variant: "error",
+        persist: true,
+        action: (key) => (
+          <Button color="inherit" onClick={() => closeSnackbar(key)}>
+            Dismiss
+          </Button>
+        ),
+      });
+    }
   }, [
     closeSnackbar,
     confirm,
@@ -123,6 +117,11 @@ export function Orchestration() {
     purgeMutation,
   ]);
 
+  const [reasonDialog, setReasonDialog] = useState<{
+    action: string;
+    fn: (reason: string) => Promise<void>;
+  } | null>(null);
+
   return (
     <div>
       <Box marginBottom={1}>
@@ -154,11 +153,59 @@ export function Orchestration() {
             setRefreshInterval={setRefreshInterval}
           />
         </Box>
-        {apiClient.isAuthorized("OrchestrationsPurgeInstance") &&
-          stateQuery.isSuccess && (
-            <Box>
+        {stateQuery.isSuccess && (
+          <Stack direction="row" spacing={1}>
+            {apiClient.isAuthorized("OrchestrationsTerminate") && (
+              <Button
+                variant="outlined"
+                startIcon={<StopIcon />}
+                size="small"
+                onClick={() =>
+                  setReasonDialog({
+                    action: "Terminate",
+                    fn: async (reason) => {
+                      await apiClient.terminateOrchestration(instanceId, {
+                        reason,
+                      });
+                      enqueueSnackbar("Termination requested", {
+                        variant: "success",
+                      });
+                      stateQuery.refetch();
+                    },
+                  })
+                }
+              >
+                Terminate
+              </Button>
+            )}
+            {apiClient.hasFeature("Rewind") &&
+              apiClient.isAuthorized("OrchestrationsRewind") && (
+                <Button
+                  variant="outlined"
+                  startIcon={<ReplayIcon />}
+                  size="small"
+                  onClick={() =>
+                    setReasonDialog({
+                      action: "Rewind",
+                      fn: async (reason) => {
+                        await apiClient.rewindOrchestration(instanceId, {
+                          reason,
+                        });
+                        enqueueSnackbar("Failures rewound", {
+                          variant: "success",
+                        });
+                        stateQuery.refetch();
+                      },
+                    })
+                  }
+                >
+                  Rewind
+                </Button>
+              )}
+            {apiClient.isAuthorized("OrchestrationsPurgeInstance") && (
               <LoadingButton
                 variant="outlined"
+                color="error"
                 startIcon={<DeleteIcon />}
                 loading={purgeMutation.isPending}
                 onClick={handlePurgeClick}
@@ -166,8 +213,9 @@ export function Orchestration() {
               >
                 Purge
               </LoadingButton>
-            </Box>
-          )}
+            )}
+          </Stack>
+        )}
       </Stack>
       <Box height={4} marginTop={0.5} marginBottom={0.5}>
         {(stateQuery.isFetching || historyQuery.isFetching) && (
@@ -197,13 +245,6 @@ export function Orchestration() {
           {apiClient.isAuthorized("OrchestrationsRaiseEvent") && (
             <Tab value="raise_event" label="Raise Event" />
           )}
-          {apiClient.isAuthorized("OrchestrationsTerminate") && (
-            <Tab value="terminate" label="Terminate" />
-          )}
-          {apiClient.hasFeature("Rewind") &&
-            apiClient.isAuthorized("OrchestrationsRewind") && (
-              <Tab value="rewind" label="Rewind" />
-            )}
           <Tab value="json" label="Json" />
         </Tabs>
         {stateQuery.data ? (
@@ -237,25 +278,6 @@ export function Orchestration() {
                   />
                 </Box>
               )}
-            {apiClient.isAuthorized("OrchestrationsTerminate") &&
-              tab === "terminate" && (
-                <Box padding={2}>
-                  <Terminate
-                    instanceId={instanceId}
-                    onTerminate={stateQuery.refetch}
-                  />
-                </Box>
-              )}
-            {apiClient.hasFeature("Rewind") &&
-              apiClient.isAuthorized("OrchestrationsRewind") &&
-              tab === "rewind" && (
-                <Box padding={2}>
-                  <Rewind
-                    instanceId={instanceId}
-                    onRewind={stateQuery.refetch}
-                  />
-                </Box>
-              )}
             {tab === "json" && (
               <Box padding={2}>
                 <pre style={{ whiteSpace: "pre-wrap", wordBreak: "break-all" }}>
@@ -270,6 +292,31 @@ export function Orchestration() {
           </>
         ) : null}
       </Paper>
+      <ReasonDialog
+        open={reasonDialog !== null}
+        title={reasonDialog?.action ?? ""}
+        description={`Provide a reason for the ${reasonDialog?.action.toLowerCase()}.`}
+        onClose={() => setReasonDialog(null)}
+        onConfirm={async (reason) => {
+          const dialog = reasonDialog;
+          setReasonDialog(null);
+          if (dialog) {
+            try {
+              await dialog.fn(reason);
+            } catch (error) {
+              enqueueSnackbar(String(error), {
+                variant: "error",
+                persist: true,
+                action: (key) => (
+                  <Button color="inherit" onClick={() => closeSnackbar(key)}>
+                    Dismiss
+                  </Button>
+                ),
+              });
+            }
+          }
+        }}
+      />
     </div>
   );
 }
diff --git a/src/LLL.DurableTask.Ui/app/src/views/orchestrations/Orchestrations.tsx b/src/LLL.DurableTask.Ui/app/src/views/orchestrations/Orchestrations.tsx
index 725af42..92e22f9 100644
--- a/src/LLL.DurableTask.Ui/app/src/views/orchestrations/Orchestrations.tsx
+++ b/src/LLL.DurableTask.Ui/app/src/views/orchestrations/Orchestrations.tsx
@@ -105,7 +105,7 @@ export function Orchestrations() {
         </Box>
       ) : null}
       <Paper variant="outlined">
-        <OrchestrationsTable result={query.data} />
+        <OrchestrationsTable result={query.data} onAction={query.refetch} />
         <Pagination
           count={query.data?.orchestrationState?.length ?? 0}
           pageSize={pageSize}
diff --git a/src/LLL.DurableTask.Ui/app/src/views/orchestrations/OrchestrationsTable.tsx b/src/LLL.DurableTask.Ui/app/src/views/orchestrations/OrchestrationsTable.tsx
index 15e3cff..46c20c2 100644
--- a/src/LLL.DurableTask.Ui/app/src/views/orchestrations/OrchestrationsTable.tsx
+++ b/src/LLL.DurableTask.Ui/app/src/views/orchestrations/OrchestrationsTable.tsx
@@ -1,32 +1,203 @@
+import DeleteIcon from "@mui/icons-material/Delete";
+import StopIcon from "@mui/icons-material/Stop";
+import ReplayIcon from "@mui/icons-material/Replay";
+import { LoadingButton } from "@mui/lab";
 import {
   Box,
+  Checkbox,
   Chip,
   Link,
+  Stack,
   Table,
   TableBody,
   TableCell,
   TableContainer,
   TableHead,
   TableRow,
+  Toolbar,
+  Typography,
 } from "@mui/material";
-import { default as React } from "react";
+import { default as React, useState } from "react";
 import { Link as RouterLink } from "react-router";
+import { useConfirm } from "material-ui-confirm";
+import { useSnackbar } from "notistack";
 import { useApiClient } from "../../hooks/useApiClient";
 import { OrchestrationsResponse } from "../../models/ApiModels";
+import { ReasonDialog } from "../../components/ReasonDialog";
 import { formatDateTime } from "../../utils/date-utils";
 
 interface Props {
   result: OrchestrationsResponse | undefined;
+  onAction?: () => void;
 }
 
-export function OrchestrationsTable({ result }: Props) {
+export function OrchestrationsTable({ result, onAction }: Props) {
   const apiClient = useApiClient();
+  const confirm = useConfirm();
+  const { enqueueSnackbar } = useSnackbar();
+  const [selected, setSelected] = useState<Set<string>>(new Set());
+
+  const orchestrations = result?.orchestrationState ?? [];
+  const instanceIds = orchestrations.map(
+    (o) => o.orchestrationInstance.instanceId,
+  );
+  const allSelected =
+    instanceIds.length > 0 && instanceIds.every((id) => selected.has(id));
+  const someSelected = instanceIds.some((id) => selected.has(id));
+
+  const toggleAll = () => {
+    if (allSelected) {
+      setSelected(new Set());
+    } else {
+      setSelected(new Set(instanceIds));
+    }
+  };
+
+  const toggleOne = (instanceId: string) => {
+    setSelected((prev) => {
+      const next = new Set(prev);
+      if (next.has(instanceId)) {
+        next.delete(instanceId);
+      } else {
+        next.add(instanceId);
+      }
+      return next;
+    });
+  };
+
+  const selectedIds = instanceIds.filter((id) => selected.has(id));
+
+  const [reasonDialog, setReasonDialog] = useState<{
+    action: string;
+    fn: (instanceId: string, reason: string) => Promise<void>;
+  } | null>(null);
+  const [loading, setLoading] = useState<string | null>(null);
+
+  const executeBulk = async (
+    ids: string[],
+    action: string,
+    fn: (instanceId: string) => Promise<void>,
+  ) => {
+    setLoading(action);
+    let succeeded = 0;
+    let failed = 0;
+    for (const id of ids) {
+      try {
+        await fn(id);
+        succeeded++;
+      } catch {
+        failed++;
+      }
+    }
+    setLoading(null);
+
+    const message =
+      failed > 0
+        ? `${action}: ${succeeded} succeeded, ${failed} failed`
+        : `${action}: ${succeeded} succeeded`;
+    enqueueSnackbar(message, {
+      variant: failed > 0 ? "warning" : "success",
+    });
+
+    setSelected(new Set());
+    onAction?.();
+  };
+
+  const runBulkAction = async (
+    action: string,
+    fn: (instanceId: string) => Promise<void>,
+  ) => {
+    const ids = [...selectedIds];
+    const { confirmed } = await confirm({
+      description: `This will ${action} ${ids.length} orchestration(s). Continue?`,
+    });
+    if (!confirmed) return;
+    executeBulk(ids, action, fn);
+  };
+
+  const hasActions =
+    apiClient.isAuthorized("OrchestrationsTerminate") ||
+    apiClient.isAuthorized("OrchestrationsPurgeInstance") ||
+    (apiClient.hasFeature("Rewind") &&
+      apiClient.isAuthorized("OrchestrationsRewind"));
 
   return (
     <TableContainer>
+      {selectedIds.length > 0 && (
+        <Toolbar variant="dense" sx={{ bgcolor: "action.selected" }}>
+          <Typography flex={1} variant="subtitle2">
+            {selectedIds.length} selected
+          </Typography>
+          <Stack direction="row" spacing={1}>
+            {apiClient.isAuthorized("OrchestrationsTerminate") && (
+              <LoadingButton
+                size="small"
+                startIcon={<StopIcon />}
+                loading={loading === "Terminate"}
+                loadingPosition="start"
+                disabled={loading !== null}
+                onClick={() =>
+                  setReasonDialog({
+                    action: "Terminate",
+                    fn: (id, reason) =>
+                      apiClient.terminateOrchestration(id, { reason }),
+                  })
+                }
+              >
+                Terminate
+              </LoadingButton>
+            )}
+            {apiClient.hasFeature("Rewind") &&
+              apiClient.isAuthorized("OrchestrationsRewind") && (
+                <LoadingButton
+                  size="small"
+                  startIcon={<ReplayIcon />}
+                  loading={loading === "Rewind"}
+                  loadingPosition="start"
+                  disabled={loading !== null}
+                  onClick={() =>
+                    setReasonDialog({
+                      action: "Rewind",
+                      fn: (id, reason) =>
+                        apiClient.rewindOrchestration(id, { reason }),
+                    })
+                  }
+                >
+                  Rewind
+                </LoadingButton>
+              )}
+            {apiClient.isAuthorized("OrchestrationsPurgeInstance") && (
+              <LoadingButton
+                size="small"
+                color="error"
+                startIcon={<DeleteIcon />}
+                loading={loading === "Purge"}
+                loadingPosition="start"
+                disabled={loading !== null}
+                onClick={() =>
+                  runBulkAction("Purge", (id) =>
+                    apiClient.purgeOrchestration(id),
+                  )
+                }
+              >
+                Purge
+              </LoadingButton>
+            )}
+          </Stack>
+        </Toolbar>
+      )}
       <Table>
         <TableHead>
           <TableRow>
+            {hasActions && (
+              <TableCell padding="checkbox">
+                <Checkbox
+                  indeterminate={someSelected && !allSelected}
+                  checked={allSelected}
+                  onChange={toggleAll}
+                />
+              </TableCell>
+            )}
             <TableCell>InstanceId</TableCell>
             <TableCell>ExecutionId</TableCell>
             <TableCell>Name</TableCell>
@@ -37,67 +208,98 @@ export function OrchestrationsTable({ result }: Props) {
           </TableRow>
         </TableHead>
         <TableBody>
-          {result?.orchestrationState.map((orchestration) => (
-            <TableRow key={orchestration.orchestrationInstance.executionId}>
-              <TableCell>
-                <Link
-                  component={RouterLink}
-                  to={`/orchestrations/${encodeURIComponent(
-                    orchestration.orchestrationInstance.instanceId
-                  )}`}
-                  underline="hover"
-                >
-                  {orchestration.orchestrationInstance.instanceId}
-                </Link>
-              </TableCell>
-              <TableCell>
-                {apiClient.hasFeature("StatePerExecution") ? (
+          {orchestrations.map((orchestration) => {
+            const instanceId = orchestration.orchestrationInstance.instanceId;
+            const isSelected = selected.has(instanceId);
+            return (
+              <TableRow
+                key={orchestration.orchestrationInstance.executionId}
+                selected={isSelected}
+              >
+                {hasActions && (
+                  <TableCell padding="checkbox">
+                    <Checkbox
+                      checked={isSelected}
+                      onChange={() => toggleOne(instanceId)}
+                    />
+                  </TableCell>
+                )}
+                <TableCell>
                   <Link
                     component={RouterLink}
-                    to={`/orchestrations/${encodeURIComponent(
-                      orchestration.orchestrationInstance.instanceId
-                    )}/${encodeURIComponent(
-                      orchestration.orchestrationInstance.executionId
-                    )}`}
+                    to={`/orchestrations/${encodeURIComponent(instanceId)}`}
                     underline="hover"
                   >
-                    {orchestration.orchestrationInstance.executionId}
+                    {instanceId}
                   </Link>
-                ) : (
-                  orchestration.orchestrationInstance.executionId
-                )}
-              </TableCell>
-              <TableCell>{orchestration.name}</TableCell>
-              <TableCell>{orchestration.orchestrationStatus}</TableCell>
-              <TableCell>{formatDateTime(orchestration.createdTime)}</TableCell>
-              <TableCell>
-                {formatDateTime(orchestration.lastUpdatedTime)}
-              </TableCell>
-              {apiClient.hasFeature("Tags") && (
-                <TableCell padding="none">
-                  <Box
-                    sx={{
-                      display: "flex",
-                      flexWrap: "wrap",
-                      mx: 1.5,
-                      "& > *": { m: 0.25 },
-                    }}
-                  >
-                    {orchestration.tags &&
-                      Object.entries(orchestration.tags).map(([key, value]) => (
-                        <Chip
-                          key={key}
-                          size="small"
-                          label={`${key}: ${value}`}
-                        />
-                      ))}
-                  </Box>
                 </TableCell>
-              )}
-            </TableRow>
-          ))}
+                <TableCell>
+                  {apiClient.hasFeature("StatePerExecution") ? (
+                    <Link
+                      component={RouterLink}
+                      to={`/orchestrations/${encodeURIComponent(
+                        instanceId,
+                      )}/${encodeURIComponent(
+                        orchestration.orchestrationInstance.executionId,
+                      )}`}
+                      underline="hover"
+                    >
+                      {orchestration.orchestrationInstance.executionId}
+                    </Link>
+                  ) : (
+                    orchestration.orchestrationInstance.executionId
+                  )}
+                </TableCell>
+                <TableCell>{orchestration.name}</TableCell>
+                <TableCell>{orchestration.orchestrationStatus}</TableCell>
+                <TableCell>
+                  {formatDateTime(orchestration.createdTime)}
+                </TableCell>
+                <TableCell>
+                  {formatDateTime(orchestration.lastUpdatedTime)}
+                </TableCell>
+                {apiClient.hasFeature("Tags") && (
+                  <TableCell padding="none">
+                    <Box
+                      sx={{
+                        display: "flex",
+                        flexWrap: "wrap",
+                        mx: 1.5,
+                        "& > *": { m: 0.25 },
+                      }}
+                    >
+                      {orchestration.tags &&
+                        Object.entries(orchestration.tags).map(
+                          ([key, value]) => (
+                            <Chip
+                              key={key}
+                              size="small"
+                              label={`${key}: ${value}`}
+                            />
+                          ),
+                        )}
+                    </Box>
+                  </TableCell>
+                )}
+              </TableRow>
+            );
+          })}
         </TableBody>
       </Table>
+      <ReasonDialog
+        open={reasonDialog !== null}
+        title={reasonDialog?.action ?? ""}
+        description={`This will ${reasonDialog?.action.toLowerCase()} ${selectedIds.length} orchestration(s).`}
+        onClose={() => setReasonDialog(null)}
+        onConfirm={(reason) => {
+          const dialog = reasonDialog;
+          const ids = [...selectedIds];
+          setReasonDialog(null);
+          if (dialog) {
+            executeBulk(ids, dialog.action, (id) => dialog.fn(id, reason));
+          }
+        }}
+      />
     </TableContainer>
   );
 }