From d190024510fd0c551bcd13c197666382bcf873cc Mon Sep 17 00:00:00 2001
From: Jerome Romualdez <jerome.romualdez@scale.com>
Date: Thu, 9 Jul 2026 09:53:19 -0400
Subject: [PATCH 1/5] feat(ui): add scheduled tasks first pass

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 agentex-ui/components/agentex-ui-root.tsx     |   1 +
 .../primary-content/primary-content.tsx       |  60 +-
 .../components/providers/agentex-provider.tsx |   5 +-
 .../scheduled-tasks/scheduled-tasks-page.tsx  | 647 ++++++++++++++++++
 .../components/task-sidebar/task-button.tsx   |   1 +
 .../task-sidebar/task-sidebar-header.tsx      |  25 +-
 .../components/task-sidebar/task-sidebar.tsx  |   1 +
 agentex-ui/hooks/use-agent-run-schedules.ts   | 176 +++++
 agentex-ui/hooks/use-safe-search-params.ts    |  12 +-
 agentex-ui/lib/agent-run-schedules.ts         | 148 ++++
 agentex-ui/lib/schedule-utils.test.ts         | 124 ++++
 agentex-ui/lib/schedule-utils.ts              | 169 +++++
 12 files changed, 1340 insertions(+), 29 deletions(-)
 create mode 100644 agentex-ui/components/scheduled-tasks/scheduled-tasks-page.tsx
 create mode 100644 agentex-ui/hooks/use-agent-run-schedules.ts
 create mode 100644 agentex-ui/lib/agent-run-schedules.ts
 create mode 100644 agentex-ui/lib/schedule-utils.test.ts
 create mode 100644 agentex-ui/lib/schedule-utils.ts

diff --git a/agentex-ui/components/agentex-ui-root.tsx b/agentex-ui/components/agentex-ui-root.tsx
index e027b974..1ac111bb 100644
--- a/agentex-ui/components/agentex-ui-root.tsx
+++ b/agentex-ui/components/agentex-ui-root.tsx
@@ -67,6 +67,7 @@ export function AgentexUIRoot() {
     (taskId: string | null) => {
       updateParams({
         [SearchParamKey.TASK_ID]: taskId,
+        [SearchParamKey.VIEW]: null,
       });
     },
     [updateParams]
diff --git a/agentex-ui/components/primary-content/primary-content.tsx b/agentex-ui/components/primary-content/primary-content.tsx
index c7bdbe78..4afcfcff 100644
--- a/agentex-ui/components/primary-content/primary-content.tsx
+++ b/agentex-ui/components/primary-content/primary-content.tsx
@@ -6,8 +6,9 @@ import { ArrowDown } from 'lucide-react';
 import { ChatView } from '@/components/primary-content/chat-view';
 import { HomeView } from '@/components/primary-content/home-view';
 import { PromptInput } from '@/components/primary-content/prompt-input';
+import { ScheduledTasksPage } from '@/components/scheduled-tasks/scheduled-tasks-page';
 import { IconButton } from '@/components/ui/icon-button';
-import { useSafeSearchParams } from '@/hooks/use-safe-search-params';
+import { AppView, useSafeSearchParams } from '@/hooks/use-safe-search-params';
 
 type ContentAreaProps = {
   isTracesSidebarOpen: boolean;
@@ -18,7 +19,8 @@ export function PrimaryContent({
   isTracesSidebarOpen,
   toggleTracesSidebar,
 }: ContentAreaProps) {
-  const { taskID } = useSafeSearchParams();
+  const { taskID, view } = useSafeSearchParams();
+  const isScheduledTasksView = view === AppView.SCHEDULED_TASKS;
 
   const [prompt, setPrompt] = useState<string>('');
   const [showScrollButton, setShowScrollButton] = useState(false);
@@ -56,20 +58,24 @@ export function PrimaryContent({
   }, [scrollContainerRef]);
 
   useEffect(() => {
-    if (scrollContainerRef.current && taskID) {
+    if (scrollContainerRef.current && taskID && !isScheduledTasksView) {
       setTimeout(() => {
         scrollToBottom();
       }, 150);
     }
-  }, [scrollToBottom, taskID]);
+  }, [scrollToBottom, taskID, isScheduledTasksView]);
 
   return (
     <motion.div
       layout
-      className={`relative flex h-full flex-1 flex-col ${!taskID ? 'justify-center' : 'justify-between'}`}
+      className={`relative flex h-full flex-1 flex-col ${
+        !taskID && !isScheduledTasksView ? 'justify-center' : 'justify-between'
+      }`}
       transition={{ duration: 0.25, ease: 'easeInOut' }}
     >
-      {taskID ? (
+      {isScheduledTasksView ? (
+        <ScheduledTasksPage />
+      ) : taskID ? (
         <ChatView
           taskID={taskID}
           isTracesSidebarOpen={isTracesSidebarOpen}
@@ -81,26 +87,28 @@ export function PrimaryContent({
         <HomeView />
       )}
 
-      <motion.div
-        layout="position"
-        className="relative flex w-full justify-center px-4 py-4 sm:px-6 md:px-8"
-        transition={{
-          layout: {
-            type: 'spring',
-            damping: 40,
-            stiffness: 300,
-            mass: 0.8,
-          },
-        }}
-      >
-        <AnimatePresence>
-          {taskID && showScrollButton && (
-            <ScrollToBottomButton scrollToBottom={scrollToBottom} />
-          )}
-        </AnimatePresence>
-
-        <PromptInput prompt={prompt} setPrompt={setPrompt} />
-      </motion.div>
+      {!isScheduledTasksView && (
+        <motion.div
+          layout="position"
+          className="relative flex w-full justify-center px-4 py-4 sm:px-6 md:px-8"
+          transition={{
+            layout: {
+              type: 'spring',
+              damping: 40,
+              stiffness: 300,
+              mass: 0.8,
+            },
+          }}
+        >
+          <AnimatePresence>
+            {taskID && showScrollButton && (
+              <ScrollToBottomButton scrollToBottom={scrollToBottom} />
+            )}
+          </AnimatePresence>
+
+          <PromptInput prompt={prompt} setPrompt={setPrompt} />
+        </motion.div>
+      )}
     </motion.div>
   );
 }
diff --git a/agentex-ui/components/providers/agentex-provider.tsx b/agentex-ui/components/providers/agentex-provider.tsx
index 4d3481ed..af927f83 100644
--- a/agentex-ui/components/providers/agentex-provider.tsx
+++ b/agentex-ui/components/providers/agentex-provider.tsx
@@ -6,6 +6,7 @@ import AgentexSDK from 'agentex';
 
 interface AgentexContextValue {
   agentexClient: AgentexSDK;
+  agentexAPIBaseURL: string;
   sgpAppURL: string;
 }
 
@@ -34,7 +35,9 @@ export function AgentexProvider({
   );
 
   return (
-    <AgentexContext.Provider value={{ agentexClient, sgpAppURL }}>
+    <AgentexContext.Provider
+      value={{ agentexClient, agentexAPIBaseURL, sgpAppURL }}
+    >
       {children}
     </AgentexContext.Provider>
   );
diff --git a/agentex-ui/components/scheduled-tasks/scheduled-tasks-page.tsx b/agentex-ui/components/scheduled-tasks/scheduled-tasks-page.tsx
new file mode 100644
index 00000000..24886538
--- /dev/null
+++ b/agentex-ui/components/scheduled-tasks/scheduled-tasks-page.tsx
@@ -0,0 +1,647 @@
+'use client';
+
+import { useMemo, useState } from 'react';
+
+import { CalendarClock, Loader2, MoreHorizontal } from 'lucide-react';
+
+import { useAgentexClient } from '@/components/providers';
+import { Button } from '@/components/ui/button';
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from '@/components/ui/select';
+import { toast } from '@/components/ui/toast';
+import { useAgentByName } from '@/hooks/use-agent-by-name';
+import {
+  useAgentRunScheduleDetails,
+  useAgentRunSchedules,
+  useCreateAgentRunSchedule,
+  useScheduleAction,
+  useUpdateAgentRunSchedule,
+} from '@/hooks/use-agent-run-schedules';
+import { useAgents } from '@/hooks/use-agents';
+import { useSafeSearchParams } from '@/hooks/use-safe-search-params';
+import type { AgentRunSchedule } from '@/lib/agent-run-schedules';
+import {
+  cadenceToPayload,
+  DEFAULT_CADENCE,
+  describeCadence,
+  generateScheduleName,
+  normalizeScheduleName,
+  scheduleToCadence,
+  type CadenceConfig,
+  type CadenceType,
+} from '@/lib/schedule-utils';
+import { cn } from '@/lib/utils';
+
+const DAYS = [
+  ['MON', 'Monday'],
+  ['TUE', 'Tuesday'],
+  ['WED', 'Wednesday'],
+  ['THU', 'Thursday'],
+  ['FRI', 'Friday'],
+  ['SAT', 'Saturday'],
+  ['SUN', 'Sunday'],
+] as const;
+
+const COMMON_TIMEZONES = [
+  'UTC',
+  'America/Los_Angeles',
+  'America/Denver',
+  'America/Chicago',
+  'America/New_York',
+  'America/Toronto',
+  'America/Sao_Paulo',
+  'Europe/London',
+  'Europe/Paris',
+  'Europe/Berlin',
+  'Asia/Dubai',
+  'Asia/Kolkata',
+  'Asia/Singapore',
+  'Asia/Tokyo',
+  'Australia/Sydney',
+] as const;
+
+function getBrowserTimezone() {
+  return Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
+}
+
+export function ScheduledTasksPage() {
+  const { agentName } = useSafeSearchParams();
+  const { agentexClient, agentexAPIBaseURL } = useAgentexClient();
+  const { data: agents = [] } = useAgents(agentexClient);
+  const { data: agentByName } = useAgentByName(agentexClient, agentName);
+  const selectedAgent =
+    agents.find(agent => agent.name === agentName) ?? agentByName ?? null;
+  const agentId = selectedAgent?.id ?? null;
+
+  const schedulesQuery = useAgentRunSchedules(agentexAPIBaseURL, agentId);
+  const schedules = schedulesQuery.data ?? [];
+  const detailQueries = useAgentRunScheduleDetails(
+    agentexAPIBaseURL,
+    agentId,
+    schedules
+  );
+  const schedulesWithLiveFields = schedules.map((schedule, index) => {
+    const detail = detailQueries[index]?.data;
+    return detail ?? schedule;
+  });
+
+  return (
+    <div className="flex h-full flex-1 flex-col overflow-hidden">
+      <div className="border-border flex items-center justify-between border-b px-8 py-5">
+        <div>
+          <h1 className="text-foreground text-xl font-semibold">
+            Scheduled Tasks
+          </h1>
+          <p className="text-muted-foreground text-sm">
+            {agentName
+              ? `Run ${agentName} automatically on a cadence.`
+              : 'Select an agent to schedule recurring tasks.'}
+          </p>
+        </div>
+      </div>
+
+      <div className="flex min-h-0 flex-1 flex-col gap-6 overflow-y-auto px-8 py-6">
+        {!selectedAgent ? (
+          <EmptyState message="Select an agent to create scheduled tasks." />
+        ) : (
+          <>
+            <ScheduleComposer
+              agentId={selectedAgent.id}
+              baseURL={agentexAPIBaseURL}
+              schedules={schedules}
+            />
+            <ScheduleList
+              agentId={selectedAgent.id}
+              baseURL={agentexAPIBaseURL}
+              schedules={schedulesWithLiveFields}
+              isLoading={schedulesQuery.isLoading}
+              error={schedulesQuery.error}
+            />
+          </>
+        )}
+      </div>
+    </div>
+  );
+}
+
+function ScheduleComposer({
+  agentId,
+  baseURL,
+  schedules,
+}: {
+  agentId: string;
+  baseURL: string;
+  schedules: AgentRunSchedule[];
+}) {
+  const [prompt, setPrompt] = useState('');
+  const [cadence, setCadence] = useState<CadenceConfig>(DEFAULT_CADENCE);
+  const [timezone, setTimezone] = useState(getBrowserTimezone);
+  const [pendingName, setPendingName] = useState<string | null>(null);
+  const createSchedule = useCreateAgentRunSchedule({ baseURL, agentId });
+
+  const handleReview = () => {
+    if (!prompt.trim()) {
+      toast.error('Enter a prompt to schedule');
+      return;
+    }
+    setPendingName(generateScheduleName(prompt, schedules));
+  };
+
+  const handleCreate = async () => {
+    if (!pendingName) return;
+    await createSchedule.mutateAsync({
+      name: pendingName,
+      timezone,
+      ...cadenceToPayload(cadence),
+      initial_input: {
+        type: 'text',
+        author: 'user',
+        content: prompt.trim(),
+      },
+    });
+    setPrompt('');
+    setPendingName(null);
+  };
+
+  return (
+    <section className="mx-auto flex w-full max-w-4xl flex-col gap-3">
+      <div className="border-input dark:bg-input flex flex-col gap-3 rounded-4xl border px-5 py-4 shadow-sm">
+        <textarea
+          value={prompt}
+          onChange={event => setPrompt(event.target.value)}
+          placeholder="What should this agent do on a schedule?"
+          className="min-h-20 resize-none bg-transparent text-sm leading-6 outline-none"
+        />
+        <div className="flex flex-wrap items-center gap-3">
+          <CadenceControls cadence={cadence} onChange={setCadence} />
+          <TimezoneSelect timezone={timezone} onChange={setTimezone} />
+          <Button
+            onClick={handleReview}
+            disabled={!prompt.trim() || createSchedule.isPending}
+            className="ml-auto rounded-full"
+          >
+            Review Schedule
+          </Button>
+        </div>
+      </div>
+      <p className="text-muted-foreground px-4 text-xs">
+        The schedule name is generated from the prompt and can be edited before
+        creation.
+      </p>
+      {pendingName && (
+        <ConfirmScheduleModal
+          title="Create scheduled task"
+          name={pendingName}
+          setName={setPendingName}
+          prompt={prompt}
+          cadence={cadence}
+          timezone={timezone}
+          onCancel={() => setPendingName(null)}
+          onConfirm={handleCreate}
+          isSubmitting={createSchedule.isPending}
+        />
+      )}
+    </section>
+  );
+}
+
+function CadenceControls({
+  cadence,
+  onChange,
+}: {
+  cadence: CadenceConfig;
+  onChange: (cadence: CadenceConfig) => void;
+}) {
+  const setField = <K extends keyof CadenceConfig>(
+    key: K,
+    value: CadenceConfig[K]
+  ) => onChange({ ...cadence, [key]: value });
+
+  return (
+    <>
+      <Select
+        value={cadence.type}
+        onValueChange={value => setField('type', value as CadenceType)}
+      >
+        <SelectTrigger className="min-w-32">
+          <SelectValue />
+        </SelectTrigger>
+        <SelectContent>
+          <SelectItem value="daily">Daily</SelectItem>
+          <SelectItem value="weekly">Weekly</SelectItem>
+          <SelectItem value="monthly">Monthly</SelectItem>
+          <SelectItem value="interval">Interval</SelectItem>
+        </SelectContent>
+      </Select>
+
+      {cadence.type !== 'interval' ? (
+        <input
+          type="time"
+          value={cadence.time}
+          onChange={event => setField('time', event.target.value)}
+          className="border-input bg-background h-9 rounded-full border px-3 text-sm"
+          aria-label="Schedule time"
+        />
+      ) : (
+        <>
+          <input
+            value={cadence.intervalValue}
+            onChange={event => setField('intervalValue', event.target.value)}
+            className="border-input bg-background h-9 w-20 rounded-full border px-3 text-sm"
+            aria-label="Interval value"
+          />
+          <Select
+            value={cadence.intervalUnit}
+            onValueChange={value =>
+              setField('intervalUnit', value as CadenceConfig['intervalUnit'])
+            }
+          >
+            <SelectTrigger className="min-w-28">
+              <SelectValue />
+            </SelectTrigger>
+            <SelectContent>
+              <SelectItem value="minutes">Minutes</SelectItem>
+              <SelectItem value="hours">Hours</SelectItem>
+              <SelectItem value="days">Days</SelectItem>
+            </SelectContent>
+          </Select>
+        </>
+      )}
+
+      {cadence.type === 'weekly' && (
+        <Select
+          value={cadence.dayOfWeek}
+          onValueChange={value => setField('dayOfWeek', value)}
+        >
+          <SelectTrigger className="min-w-36">
+            <SelectValue />
+          </SelectTrigger>
+          <SelectContent>
+            {DAYS.map(([value, label]) => (
+              <SelectItem key={value} value={value}>
+                {label}
+              </SelectItem>
+            ))}
+          </SelectContent>
+        </Select>
+      )}
+
+      {cadence.type === 'monthly' && (
+        <input
+          value={cadence.dayOfMonth}
+          onChange={event => setField('dayOfMonth', event.target.value)}
+          className="border-input bg-background h-9 w-24 rounded-full border px-3 text-sm"
+          aria-label="Day of month"
+          placeholder="Day"
+        />
+      )}
+    </>
+  );
+}
+
+function TimezoneSelect({
+  timezone,
+  onChange,
+}: {
+  timezone: string;
+  onChange: (timezone: string) => void;
+}) {
+  const timezoneOptions = useMemo(() => {
+    const options = new Set<string>([timezone, getBrowserTimezone()]);
+
+    for (const commonTimezone of COMMON_TIMEZONES) {
+      options.add(commonTimezone);
+    }
+
+    return Array.from(options).filter(Boolean);
+  }, [timezone]);
+
+  return (
+    <Select value={timezone} onValueChange={onChange}>
+      <SelectTrigger className="min-w-52">
+        <SelectValue placeholder="Timezone" />
+      </SelectTrigger>
+      <SelectContent>
+        {timezoneOptions.map(option => (
+          <SelectItem key={option} value={option}>
+            {option.replace('_', ' ')}
+          </SelectItem>
+        ))}
+      </SelectContent>
+    </Select>
+  );
+}
+
+function ScheduleList({
+  agentId,
+  baseURL,
+  schedules,
+  isLoading,
+  error,
+}: {
+  agentId: string;
+  baseURL: string;
+  schedules: AgentRunSchedule[];
+  isLoading: boolean;
+  error: Error | null;
+}) {
+  if (isLoading) {
+    return (
+      <div className="text-muted-foreground flex items-center justify-center py-12 text-sm">
+        <Loader2 className="mr-2 size-4 animate-spin" />
+        Loading scheduled tasks
+      </div>
+    );
+  }
+
+  if (error) {
+    return (
+      <EmptyState message="Scheduled tasks are unavailable. Check that schedule routes are enabled locally." />
+    );
+  }
+
+  if (schedules.length === 0) {
+    return <EmptyState message="No scheduled tasks yet" />;
+  }
+
+  return (
+    <section className="mx-auto grid w-full max-w-4xl gap-3">
+      {schedules.map(schedule => (
+        <ScheduleCard
+          key={schedule.id}
+          agentId={agentId}
+          baseURL={baseURL}
+          schedule={schedule}
+        />
+      ))}
+    </section>
+  );
+}
+
+function ScheduleCard({
+  agentId,
+  baseURL,
+  schedule,
+}: {
+  agentId: string;
+  baseURL: string;
+  schedule: AgentRunSchedule;
+}) {
+  const [isEditing, setIsEditing] = useState(false);
+  const pause = useScheduleAction({ baseURL, agentId, action: 'pause' });
+  const resume = useScheduleAction({ baseURL, agentId, action: 'resume' });
+  const trigger = useScheduleAction({ baseURL, agentId, action: 'trigger' });
+  const deleteSchedule = useScheduleAction({
+    baseURL,
+    agentId,
+    action: 'delete',
+  });
+  const isPaused = schedule.state === 'PAUSED' || schedule.paused;
+  const nextRun = schedule.next_action_times[0];
+
+  return (
+    <article className="border-border bg-card rounded-2xl border p-4 shadow-sm">
+      <div className="flex items-start justify-between gap-4">
+        <div className="min-w-0">
+          <div className="flex items-center gap-2">
+            <h2 className="truncate text-sm font-semibold">{schedule.name}</h2>
+            <span
+              className={cn(
+                'rounded-full px-2 py-0.5 text-xs',
+                isPaused
+                  ? 'bg-muted text-muted-foreground'
+                  : 'bg-green-500/10 text-green-700 dark:text-green-400'
+              )}
+            >
+              {isPaused ? 'Paused' : 'Active'}
+            </span>
+          </div>
+          <p className="text-muted-foreground mt-1 line-clamp-2 text-sm">
+            {schedule.initial_input.content}
+          </p>
+          <p className="text-muted-foreground mt-2 text-xs">
+            {describeCadence(schedule)} · {schedule.timezone}
+            {nextRun ? ` · Next run ${new Date(nextRun).toLocaleString()}` : ''}
+          </p>
+        </div>
+        <div className="flex flex-wrap justify-end gap-2">
+          <Button
+            variant="outline"
+            size="sm"
+            onClick={() => trigger.mutate(schedule.id)}
+            disabled={trigger.isPending}
+          >
+            Run Now
+          </Button>
+          <Button
+            variant="outline"
+            size="sm"
+            onClick={() =>
+              isPaused ? resume.mutate(schedule.id) : pause.mutate(schedule.id)
+            }
+            disabled={pause.isPending || resume.isPending}
+          >
+            {isPaused ? 'Resume' : 'Pause'}
+          </Button>
+          <Button
+            variant="outline"
+            size="sm"
+            onClick={() => setIsEditing(true)}
+          >
+            Edit
+          </Button>
+          <Button
+            variant="destructive"
+            size="sm"
+            onClick={() => deleteSchedule.mutate(schedule.id)}
+            disabled={deleteSchedule.isPending}
+          >
+            Delete
+          </Button>
+          <MoreHorizontal className="text-muted-foreground mt-1 size-4" />
+        </div>
+      </div>
+      {isEditing && (
+        <EditScheduleModal
+          agentId={agentId}
+          baseURL={baseURL}
+          schedule={schedule}
+          onClose={() => setIsEditing(false)}
+        />
+      )}
+    </article>
+  );
+}
+
+function EditScheduleModal({
+  agentId,
+  baseURL,
+  schedule,
+  onClose,
+}: {
+  agentId: string;
+  baseURL: string;
+  schedule: AgentRunSchedule;
+  onClose: () => void;
+}) {
+  const [name, setName] = useState(schedule.name);
+  const [prompt, setPrompt] = useState(schedule.initial_input.content);
+  const [cadence, setCadence] = useState(() => scheduleToCadence(schedule));
+  const [timezone, setTimezone] = useState(schedule.timezone);
+  const updateSchedule = useUpdateAgentRunSchedule({ baseURL, agentId });
+
+  const handleSave = async () => {
+    await updateSchedule.mutateAsync({
+      scheduleId: schedule.id,
+      payload: {
+        name,
+        timezone,
+        ...cadenceToPayload(cadence),
+        initial_input: {
+          type: 'text',
+          author: 'user',
+          content: prompt.trim(),
+        },
+      },
+    });
+    onClose();
+  };
+
+  return (
+    <BasicModal title="Edit scheduled task" onClose={onClose}>
+      <ScheduleNameInput name={name} setName={setName} />
+      <textarea
+        value={prompt}
+        onChange={event => setPrompt(event.target.value)}
+        className="border-input bg-background min-h-24 rounded-md border p-3 text-sm"
+      />
+      <div className="flex flex-wrap items-center gap-3">
+        <CadenceControls cadence={cadence} onChange={setCadence} />
+      </div>
+      <TimezoneSelect timezone={timezone} onChange={setTimezone} />
+      <div className="flex justify-end gap-2">
+        <Button variant="outline" onClick={onClose}>
+          Cancel
+        </Button>
+        <Button
+          onClick={handleSave}
+          disabled={!name.trim() || !prompt.trim() || updateSchedule.isPending}
+        >
+          Save
+        </Button>
+      </div>
+    </BasicModal>
+  );
+}
+
+function ConfirmScheduleModal({
+  title,
+  name,
+  setName,
+  prompt,
+  cadence,
+  timezone,
+  onCancel,
+  onConfirm,
+  isSubmitting,
+}: {
+  title: string;
+  name: string;
+  setName: (name: string) => void;
+  prompt: string;
+  cadence: CadenceConfig;
+  timezone: string;
+  onCancel: () => void;
+  onConfirm: () => void;
+  isSubmitting: boolean;
+}) {
+  const cadencePreview = useMemo(() => cadenceToPayload(cadence), [cadence]);
+
+  return (
+    <BasicModal title={title} onClose={onCancel}>
+      <ScheduleNameInput name={name} setName={setName} />
+      <div className="bg-muted rounded-md p-3 text-sm">
+        <p className="font-medium">Prompt</p>
+        <p className="text-muted-foreground mt-1 whitespace-pre-wrap">
+          {prompt}
+        </p>
+      </div>
+      <div className="text-muted-foreground text-sm">
+        Cadence:{' '}
+        {'cron_expression' in cadencePreview
+          ? cadencePreview.cron_expression
+          : `Every ${cadencePreview.interval_seconds} seconds`}
+        {' · '}
+        {timezone}
+      </div>
+      <div className="flex justify-end gap-2">
+        <Button variant="outline" onClick={onCancel}>
+          Cancel
+        </Button>
+        <Button onClick={onConfirm} disabled={!name.trim() || isSubmitting}>
+          Create
+        </Button>
+      </div>
+    </BasicModal>
+  );
+}
+
+function ScheduleNameInput({
+  name,
+  setName,
+}: {
+  name: string;
+  setName: (name: string) => void;
+}) {
+  return (
+    <label className="flex flex-col gap-1 text-sm">
+      <span className="font-medium">Name</span>
+      <input
+        value={name}
+        onChange={event => setName(normalizeScheduleName(event.target.value))}
+        className="border-input bg-background h-9 rounded-md border px-3"
+      />
+      <span className="text-muted-foreground text-xs">
+        Use lowercase letters, numbers, and hyphens.
+      </span>
+    </label>
+  );
+}
+
+function BasicModal({
+  title,
+  children,
+  onClose,
+}: {
+  title: string;
+  children: React.ReactNode;
+  onClose: () => void;
+}) {
+  return (
+    <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/30 p-4">
+      <div className="bg-background w-full max-w-lg rounded-2xl border p-5 shadow-xl">
+        <div className="mb-4 flex items-center justify-between">
+          <h2 className="text-base font-semibold">{title}</h2>
+          <Button variant="ghost" size="sm" onClick={onClose}>
+            Close
+          </Button>
+        </div>
+        <div className="flex flex-col gap-4">{children}</div>
+      </div>
+    </div>
+  );
+}
+
+function EmptyState({ message }: { message: string }) {
+  return (
+    <div className="border-border text-muted-foreground mx-auto flex min-h-52 w-full max-w-4xl flex-col items-center justify-center rounded-2xl border border-dashed p-8 text-sm">
+      <CalendarClock className="mb-3 size-8" />
+      {message}
+    </div>
+  );
+}
diff --git a/agentex-ui/components/task-sidebar/task-button.tsx b/agentex-ui/components/task-sidebar/task-button.tsx
index 2d85093d..19cfa4fe 100644
--- a/agentex-ui/components/task-sidebar/task-button.tsx
+++ b/agentex-ui/components/task-sidebar/task-button.tsx
@@ -30,6 +30,7 @@ function TaskButtonImpl({ task }: TaskButtonProps) {
       updateParams({
         [SearchParamKey.TASK_ID]: taskID,
         [SearchParamKey.AGENT_NAME]: firstAgentName,
+        [SearchParamKey.VIEW]: null,
       });
     },
     [updateParams, firstAgentName]
diff --git a/agentex-ui/components/task-sidebar/task-sidebar-header.tsx b/agentex-ui/components/task-sidebar/task-sidebar-header.tsx
index dd5b2081..8d9430d7 100644
--- a/agentex-ui/components/task-sidebar/task-sidebar-header.tsx
+++ b/agentex-ui/components/task-sidebar/task-sidebar-header.tsx
@@ -1,9 +1,14 @@
 import Image from 'next/image';
 import { useRouter } from 'next/navigation';
 
-import { PanelLeftClose, MessageSquarePlus } from 'lucide-react';
+import { CalendarClock, PanelLeftClose, MessageSquarePlus } from 'lucide-react';
 
 import { Button } from '@/components/ui/button';
+import {
+  AppView,
+  SearchParamKey,
+  useSafeSearchParams,
+} from '@/hooks/use-safe-search-params';
 import { cn } from '@/lib/utils';
 
 import { IconButton } from '../ui/icon-button';
@@ -21,6 +26,14 @@ export function TaskSidebarHeader({
   className,
 }: TaskSidebarHeaderProps) {
   const router = useRouter();
+  const { view, updateParams } = useSafeSearchParams();
+
+  const handleScheduledTasks = () => {
+    updateParams({
+      [SearchParamKey.TASK_ID]: null,
+      [SearchParamKey.VIEW]: AppView.SCHEDULED_TASKS,
+    });
+  };
 
   return (
     <div className={cn('flex flex-col gap-4 px-2', className)}>
@@ -56,6 +69,16 @@ export function TaskSidebarHeader({
           <span className="text-xs/snug">⌘</span>K
         </kbd>
       </ResizableSidebar.Button>
+      <ResizableSidebar.Button
+        onClick={handleScheduledTasks}
+        isSelected={view === AppView.SCHEDULED_TASKS}
+        className="text-foreground flex items-center gap-2 p-2"
+        aria-label="Scheduled Tasks"
+        disableAnimation={true}
+      >
+        <CalendarClock className="size-5" />
+        Scheduled Tasks
+      </ResizableSidebar.Button>
     </div>
   );
 }
diff --git a/agentex-ui/components/task-sidebar/task-sidebar.tsx b/agentex-ui/components/task-sidebar/task-sidebar.tsx
index 6ea1b1ff..d45f8afd 100644
--- a/agentex-ui/components/task-sidebar/task-sidebar.tsx
+++ b/agentex-ui/components/task-sidebar/task-sidebar.tsx
@@ -20,6 +20,7 @@ export function TaskSidebar() {
   const handleNewChat = useCallback(() => {
     updateParams({
       [SearchParamKey.TASK_ID]: null,
+      [SearchParamKey.VIEW]: null,
     });
   }, [updateParams]);
 
diff --git a/agentex-ui/hooks/use-agent-run-schedules.ts b/agentex-ui/hooks/use-agent-run-schedules.ts
new file mode 100644
index 00000000..8d678b3c
--- /dev/null
+++ b/agentex-ui/hooks/use-agent-run-schedules.ts
@@ -0,0 +1,176 @@
+import {
+  useMutation,
+  useQueries,
+  useQuery,
+  useQueryClient,
+} from '@tanstack/react-query';
+
+import { toast } from '@/components/ui/toast';
+import {
+  agentRunSchedulesAPI,
+  type AgentRunSchedule,
+  type CreateAgentRunScheduleRequest,
+  type UpdateAgentRunScheduleRequest,
+} from '@/lib/agent-run-schedules';
+
+export const scheduleKeys = {
+  all: ['agentRunSchedules'] as const,
+  byAgentId: (agentId: string | null) =>
+    agentId
+      ? ([...scheduleKeys.all, 'agent', agentId] as const)
+      : scheduleKeys.all,
+  detail: (agentId: string, scheduleId: string) =>
+    [...scheduleKeys.byAgentId(agentId), 'detail', scheduleId] as const,
+};
+
+type ScheduleMutationContext = {
+  baseURL: string;
+  agentId: string;
+};
+
+function errorMessage(error: unknown) {
+  return error instanceof Error ? error.message : 'Please try again.';
+}
+
+export function useAgentRunSchedules(baseURL: string, agentId: string | null) {
+  return useQuery({
+    queryKey: scheduleKeys.byAgentId(agentId),
+    queryFn: async () => {
+      if (!agentId) {
+        return [];
+      }
+      const response = await agentRunSchedulesAPI.list(baseURL, agentId);
+      return response.run_schedules;
+    },
+    enabled: !!agentId,
+  });
+}
+
+export function useAgentRunScheduleDetails(
+  baseURL: string,
+  agentId: string | null,
+  schedules: AgentRunSchedule[]
+) {
+  return useQueries({
+    queries:
+      agentId == null
+        ? []
+        : schedules.map(schedule => ({
+            queryKey: scheduleKeys.detail(agentId, schedule.id),
+            queryFn: () =>
+              agentRunSchedulesAPI.get(baseURL, agentId, schedule.id),
+            staleTime: 30_000,
+          })),
+  });
+}
+
+export function useCreateAgentRunSchedule({
+  baseURL,
+  agentId,
+}: ScheduleMutationContext) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: (payload: CreateAgentRunScheduleRequest) =>
+      agentRunSchedulesAPI.create(baseURL, agentId, payload),
+    onSuccess: schedule => {
+      queryClient.invalidateQueries({
+        queryKey: scheduleKeys.byAgentId(agentId),
+      });
+      queryClient.setQueryData(
+        scheduleKeys.detail(agentId, schedule.id),
+        schedule
+      );
+      toast.success('Scheduled task created');
+    },
+    onError: error => {
+      toast.error({
+        title: 'Failed to create scheduled task',
+        message: errorMessage(error),
+      });
+    },
+  });
+}
+
+export function useUpdateAgentRunSchedule({
+  baseURL,
+  agentId,
+}: ScheduleMutationContext) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: ({
+      scheduleId,
+      payload,
+    }: {
+      scheduleId: string;
+      payload: UpdateAgentRunScheduleRequest;
+    }) => agentRunSchedulesAPI.update(baseURL, agentId, scheduleId, payload),
+    onSuccess: schedule => {
+      queryClient.invalidateQueries({
+        queryKey: scheduleKeys.byAgentId(agentId),
+      });
+      queryClient.setQueryData(
+        scheduleKeys.detail(agentId, schedule.id),
+        schedule
+      );
+      toast.success('Scheduled task updated');
+    },
+    onError: error => {
+      toast.error({
+        title: 'Failed to update scheduled task',
+        message: errorMessage(error),
+      });
+    },
+  });
+}
+
+export function useScheduleAction({
+  baseURL,
+  agentId,
+  action,
+}: ScheduleMutationContext & {
+  action: 'delete' | 'pause' | 'resume' | 'trigger';
+}) {
+  const queryClient = useQueryClient();
+
+  return useMutation<
+    AgentRunSchedule | { id: string; message: string },
+    Error,
+    string
+  >({
+    mutationFn: (scheduleId: string) => {
+      switch (action) {
+        case 'delete':
+          return agentRunSchedulesAPI.delete(baseURL, agentId, scheduleId);
+        case 'pause':
+          return agentRunSchedulesAPI.pause(baseURL, agentId, scheduleId);
+        case 'resume':
+          return agentRunSchedulesAPI.resume(baseURL, agentId, scheduleId);
+        case 'trigger':
+          return agentRunSchedulesAPI.trigger(baseURL, agentId, scheduleId);
+      }
+    },
+    onSuccess: result => {
+      queryClient.invalidateQueries({
+        queryKey: scheduleKeys.byAgentId(agentId),
+      });
+      if ('id' in result) {
+        queryClient.invalidateQueries({
+          queryKey: scheduleKeys.detail(agentId, result.id),
+        });
+      }
+      toast.success(
+        action === 'trigger'
+          ? 'Scheduled task triggered'
+          : `Scheduled task ${action === 'delete' ? 'deleted' : `${action}d`}`
+      );
+    },
+    onError: error => {
+      toast.error({
+        title: `Failed to ${action} scheduled task`,
+        message: errorMessage(error),
+      });
+    },
+  });
+}
diff --git a/agentex-ui/hooks/use-safe-search-params.ts b/agentex-ui/hooks/use-safe-search-params.ts
index f6ba3fd5..20d63323 100644
--- a/agentex-ui/hooks/use-safe-search-params.ts
+++ b/agentex-ui/hooks/use-safe-search-params.ts
@@ -6,14 +6,20 @@ export enum SearchParamKey {
   SGP_ACCOUNT_ID = 'account_id',
   TASK_ID = 'task_id',
   AGENT_NAME = 'agent_name',
+  VIEW = 'view',
 }
 
 type SearchParamUpdates = Partial<Record<SearchParamKey, string | null>>;
 
+export enum AppView {
+  SCHEDULED_TASKS = 'scheduled_tasks',
+}
+
 type SafeSearchParams = {
   sgpAccountID: string | null;
   taskID: string | null;
   agentName: string | null;
+  view: AppView | null;
   updateParams: (updates: SearchParamUpdates, replace?: boolean) => void;
 };
 
@@ -28,6 +34,9 @@ export function useSafeSearchParams(): SafeSearchParams {
   const sgpAccountID = searchParams.get(SearchParamKey.SGP_ACCOUNT_ID);
   const taskID = searchParams.get(SearchParamKey.TASK_ID);
   const agentName = searchParams.get(SearchParamKey.AGENT_NAME);
+  const viewParam = searchParams.get(SearchParamKey.VIEW);
+  const view =
+    viewParam === AppView.SCHEDULED_TASKS ? AppView.SCHEDULED_TASKS : null;
 
   const updateParams = useCallback(
     (updates: SearchParamUpdates, replace: boolean = false): void => {
@@ -58,8 +67,9 @@ export function useSafeSearchParams(): SafeSearchParams {
       sgpAccountID: sgpAccountID || null,
       taskID: taskID || null,
       agentName: agentName || null,
+      view,
       updateParams,
     }),
-    [sgpAccountID, taskID, agentName, updateParams]
+    [sgpAccountID, taskID, agentName, view, updateParams]
   );
 }
diff --git a/agentex-ui/lib/agent-run-schedules.ts b/agentex-ui/lib/agent-run-schedules.ts
new file mode 100644
index 00000000..fded0e04
--- /dev/null
+++ b/agentex-ui/lib/agent-run-schedules.ts
@@ -0,0 +1,148 @@
+export type ScheduleInitialInput = {
+  type: 'text';
+  author: 'user';
+  content: string;
+};
+
+export type AgentRunSchedule = {
+  id: string;
+  agent_id: string;
+  name: string;
+  description: string | null;
+  cron_expression: string | null;
+  interval_seconds: number | null;
+  timezone: string;
+  start_at: string | null;
+  end_at: string | null;
+  paused: boolean;
+  task_params: Record<string, unknown> | null;
+  task_metadata: Record<string, unknown> | null;
+  initial_input: ScheduleInitialInput;
+  initial_input_method: string;
+  created_at: string | null;
+  updated_at: string | null;
+  state: 'ACTIVE' | 'PAUSED';
+  next_action_times: string[];
+  last_action_time: string | null;
+  num_actions_taken: number;
+};
+
+export type AgentRunScheduleListResponse = {
+  run_schedules: AgentRunSchedule[];
+  total: number;
+};
+
+export type CreateAgentRunScheduleRequest = {
+  name: string;
+  description?: string | null;
+  cron_expression?: string | null;
+  interval_seconds?: number | null;
+  timezone?: string;
+  paused?: boolean;
+  initial_input: ScheduleInitialInput;
+  task_params?: Record<string, unknown> | null;
+  task_metadata?: Record<string, unknown> | null;
+};
+
+export type UpdateAgentRunScheduleRequest = Partial<
+  Omit<CreateAgentRunScheduleRequest, 'initial_input'> & {
+    initial_input: ScheduleInitialInput;
+  }
+>;
+
+async function request<T>(
+  baseURL: string,
+  path: string,
+  init?: RequestInit
+): Promise<T> {
+  const response = await fetch(`${baseURL}${path}`, {
+    ...init,
+    credentials: 'include',
+    headers: {
+      'Content-Type': 'application/json',
+      ...init?.headers,
+    },
+  });
+
+  if (!response.ok) {
+    const detail = await response.text();
+    throw new Error(detail || `Request failed with status ${response.status}`);
+  }
+
+  if (response.status === 204) {
+    return undefined as T;
+  }
+
+  return (await response.json()) as T;
+}
+
+function schedulesPath(agentId: string) {
+  return `/agents/${encodeURIComponent(agentId)}/schedules`;
+}
+
+export const agentRunSchedulesAPI = {
+  list: (baseURL: string, agentId: string) =>
+    request<AgentRunScheduleListResponse>(
+      baseURL,
+      `${schedulesPath(agentId)}?limit=100`
+    ),
+
+  get: (baseURL: string, agentId: string, scheduleId: string) =>
+    request<AgentRunSchedule>(
+      baseURL,
+      `${schedulesPath(agentId)}/${encodeURIComponent(scheduleId)}`
+    ),
+
+  create: (
+    baseURL: string,
+    agentId: string,
+    payload: CreateAgentRunScheduleRequest
+  ) =>
+    request<AgentRunSchedule>(baseURL, schedulesPath(agentId), {
+      method: 'POST',
+      body: JSON.stringify(payload),
+    }),
+
+  update: (
+    baseURL: string,
+    agentId: string,
+    scheduleId: string,
+    payload: UpdateAgentRunScheduleRequest
+  ) =>
+    request<AgentRunSchedule>(
+      baseURL,
+      `${schedulesPath(agentId)}/${encodeURIComponent(scheduleId)}`,
+      {
+        method: 'PATCH',
+        body: JSON.stringify(payload),
+      }
+    ),
+
+  delete: (baseURL: string, agentId: string, scheduleId: string) =>
+    request<{ id: string; message: string }>(
+      baseURL,
+      `${schedulesPath(agentId)}/${encodeURIComponent(scheduleId)}`,
+      { method: 'DELETE' }
+    ),
+
+  pause: (baseURL: string, agentId: string, scheduleId: string) =>
+    request<AgentRunSchedule>(
+      baseURL,
+      `${schedulesPath(agentId)}/${encodeURIComponent(scheduleId)}/pause`,
+      { method: 'POST', body: JSON.stringify({}) }
+    ),
+
+  resume: (baseURL: string, agentId: string, scheduleId: string) =>
+    request<AgentRunSchedule>(
+      baseURL,
+      `${schedulesPath(agentId)}/${encodeURIComponent(scheduleId)}/resume`,
+      { method: 'POST', body: JSON.stringify({}) }
+    ),
+
+  trigger: (baseURL: string, agentId: string, scheduleId: string) =>
+    request<AgentRunSchedule>(
+      baseURL,
+      `${schedulesPath(agentId)}/${encodeURIComponent(scheduleId)}/trigger`,
+      { method: 'POST' }
+    ),
+};
diff --git a/agentex-ui/lib/schedule-utils.test.ts b/agentex-ui/lib/schedule-utils.test.ts
new file mode 100644
index 00000000..e8106278
--- /dev/null
+++ b/agentex-ui/lib/schedule-utils.test.ts
@@ -0,0 +1,124 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  cadenceToPayload,
+  generateScheduleName,
+  normalizeScheduleName,
+  scheduleToCadence,
+  type CadenceConfig,
+} from './schedule-utils';
+
+import type { AgentRunSchedule } from './agent-run-schedules';
+
+describe('generateScheduleName', () => {
+  it('slugifies prompt text', () => {
+    expect(generateScheduleName('Daily Granola summary!', [])).toBe(
+      'daily-granola-summary'
+    );
+  });
+
+  it('adds a suffix when the name already exists', () => {
+    expect(
+      generateScheduleName('Daily Granola summary', [
+        { name: 'daily-granola-summary' },
+      ])
+    ).toBe('daily-granola-summary-2');
+  });
+
+  it('falls back for empty prompts', () => {
+    expect(generateScheduleName('', [])).toBe('scheduled-task');
+  });
+});
+
+describe('normalizeScheduleName', () => {
+  it('keeps editable names within backend slug constraints', () => {
+    expect(normalizeScheduleName('  Daily Summary!!! ')).toBe('daily-summary');
+  });
+});
+
+describe('cadenceToPayload', () => {
+  const base: CadenceConfig = {
+    type: 'daily',
+    time: '09:30',
+    dayOfWeek: 'MON',
+    dayOfMonth: '1',
+    intervalValue: '1',
+    intervalUnit: 'hours',
+  };
+
+  it('converts daily cadence to cron', () => {
+    expect(cadenceToPayload(base)).toEqual({ cron_expression: '30 9 * * *' });
+  });
+
+  it('converts weekly cadence to cron', () => {
+    expect(cadenceToPayload({ ...base, type: 'weekly' })).toEqual({
+      cron_expression: '30 9 * * MON',
+    });
+  });
+
+  it('converts monthly cadence to cron', () => {
+    expect(
+      cadenceToPayload({ ...base, type: 'monthly', dayOfMonth: '15' })
+    ).toEqual({
+      cron_expression: '30 9 15 * *',
+    });
+  });
+
+  it('converts interval cadence to seconds', () => {
+    expect(
+      cadenceToPayload({
+        ...base,
+        type: 'interval',
+        intervalValue: '2',
+        intervalUnit: 'hours',
+      })
+    ).toEqual({ interval_seconds: 7200 });
+  });
+});
+
+describe('scheduleToCadence', () => {
+  const schedule = {
+    id: 'schedule-id',
+    agent_id: 'agent-id',
+    name: 'schedule',
+    description: null,
+    cron_expression: '30 9 * * MON',
+    interval_seconds: null,
+    timezone: 'UTC',
+    start_at: null,
+    end_at: null,
+    paused: false,
+    task_params: null,
+    task_metadata: null,
+    initial_input: { type: 'text', author: 'user', content: 'Run this' },
+    initial_input_method: 'send_message',
+    created_at: null,
+    updated_at: null,
+    state: 'ACTIVE',
+    next_action_times: [],
+    last_action_time: null,
+    num_actions_taken: 0,
+  } satisfies AgentRunSchedule;
+
+  it('converts weekly cron to editable cadence config', () => {
+    expect(scheduleToCadence(schedule)).toMatchObject({
+      type: 'weekly',
+      time: '09:30',
+      dayOfWeek: 'MON',
+    });
+  });
+
+  it('converts interval seconds to editable cadence config', () => {
+    expect(
+      scheduleToCadence({
+        ...schedule,
+        cron_expression: null,
+        interval_seconds: 7200,
+      })
+    ).toMatchObject({
+      type: 'interval',
+      intervalValue: '2',
+      intervalUnit: 'hours',
+    });
+  });
+});
diff --git a/agentex-ui/lib/schedule-utils.ts b/agentex-ui/lib/schedule-utils.ts
new file mode 100644
index 00000000..d89a0527
--- /dev/null
+++ b/agentex-ui/lib/schedule-utils.ts
@@ -0,0 +1,169 @@
+import type { AgentRunSchedule } from '@/lib/agent-run-schedules';
+
+export type CadenceType = 'daily' | 'weekly' | 'monthly' | 'interval';
+
+export type CadenceConfig = {
+  type: CadenceType;
+  time: string;
+  dayOfWeek: string;
+  dayOfMonth: string;
+  intervalValue: string;
+  intervalUnit: 'minutes' | 'hours' | 'days';
+};
+
+export const DEFAULT_CADENCE: CadenceConfig = {
+  type: 'daily',
+  time: '09:00',
+  dayOfWeek: 'MON',
+  dayOfMonth: '1',
+  intervalValue: '1',
+  intervalUnit: 'hours',
+};
+
+export function normalizeScheduleName(value: string): string {
+  return value
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 64)
+    .replace(/-+$/g, '');
+}
+
+export function generateScheduleName(
+  prompt: string,
+  existingSchedules: Pick<AgentRunSchedule, 'name'>[]
+): string {
+  const existingNames = new Set(
+    existingSchedules.map(schedule => schedule.name)
+  );
+  const words = prompt.trim().split(/\s+/).slice(0, 6).join(' ');
+  const base = normalizeScheduleName(words) || 'scheduled-task';
+
+  if (!existingNames.has(base)) {
+    return base;
+  }
+
+  for (let suffix = 2; suffix < 100; suffix += 1) {
+    const suffixText = `-${suffix}`;
+    const candidate = `${base.slice(0, 64 - suffixText.length)}${suffixText}`;
+    if (!existingNames.has(candidate)) {
+      return candidate;
+    }
+  }
+
+  return `${base.slice(0, 55)}-${Date.now().toString().slice(-8)}`;
+}
+
+export function cadenceToPayload(
+  cadence: CadenceConfig
+):
+  | { cron_expression: string; interval_seconds?: never }
+  | { interval_seconds: number; cron_expression?: never } {
+  if (cadence.type === 'interval') {
+    const value = Math.max(1, Number.parseInt(cadence.intervalValue, 10) || 1);
+    const multiplier =
+      cadence.intervalUnit === 'minutes'
+        ? 60
+        : cadence.intervalUnit === 'hours'
+          ? 60 * 60
+          : 24 * 60 * 60;
+    return { interval_seconds: value * multiplier };
+  }
+
+  const [hour = '9', minute = '0'] = cadence.time.split(':');
+  const cronMinute = Number.parseInt(minute, 10) || 0;
+  const cronHour = Number.parseInt(hour, 10) || 0;
+
+  if (cadence.type === 'weekly') {
+    return {
+      cron_expression: `${cronMinute} ${cronHour} * * ${cadence.dayOfWeek}`,
+    };
+  }
+
+  if (cadence.type === 'monthly') {
+    const day = Math.min(
+      31,
+      Math.max(1, Number.parseInt(cadence.dayOfMonth, 10) || 1)
+    );
+    return { cron_expression: `${cronMinute} ${cronHour} ${day} * *` };
+  }
+
+  return { cron_expression: `${cronMinute} ${cronHour} * * *` };
+}
+
+export function describeCadence(schedule: AgentRunSchedule): string {
+  if (schedule.interval_seconds != null) {
+    if (schedule.interval_seconds % 86400 === 0) {
+      return `Every ${schedule.interval_seconds / 86400} day(s)`;
+    }
+    if (schedule.interval_seconds % 3600 === 0) {
+      return `Every ${schedule.interval_seconds / 3600} hour(s)`;
+    }
+    if (schedule.interval_seconds % 60 === 0) {
+      return `Every ${schedule.interval_seconds / 60} minute(s)`;
+    }
+    return `Every ${schedule.interval_seconds} second(s)`;
+  }
+
+  return schedule.cron_expression ?? 'No cadence';
+}
+
+export function scheduleToCadence(schedule: AgentRunSchedule): CadenceConfig {
+  if (schedule.interval_seconds != null) {
+    if (schedule.interval_seconds % 86400 === 0) {
+      return {
+        ...DEFAULT_CADENCE,
+        type: 'interval',
+        intervalValue: String(schedule.interval_seconds / 86400),
+        intervalUnit: 'days',
+      };
+    }
+    if (schedule.interval_seconds % 3600 === 0) {
+      return {
+        ...DEFAULT_CADENCE,
+        type: 'interval',
+        intervalValue: String(schedule.interval_seconds / 3600),
+        intervalUnit: 'hours',
+      };
+    }
+    return {
+      ...DEFAULT_CADENCE,
+      type: 'interval',
+      intervalValue: String(
+        Math.max(1, Math.floor(schedule.interval_seconds / 60))
+      ),
+      intervalUnit: 'minutes',
+    };
+  }
+
+  const [minute, hour, dayOfMonth, , dayOfWeek] =
+    schedule.cron_expression?.split(' ') ?? [];
+  const time =
+    hour != null && minute != null
+      ? `${hour.padStart(2, '0')}:${minute.padStart(2, '0')}`
+      : DEFAULT_CADENCE.time;
+
+  if (dayOfMonth != null && dayOfMonth !== '*') {
+    return {
+      ...DEFAULT_CADENCE,
+      type: 'monthly',
+      time,
+      dayOfMonth,
+    };
+  }
+
+  if (dayOfWeek != null && dayOfWeek !== '*') {
+    return {
+      ...DEFAULT_CADENCE,
+      type: 'weekly',
+      time,
+      dayOfWeek,
+    };
+  }
+
+  return {
+    ...DEFAULT_CADENCE,
+    type: 'daily',
+    time,
+  };
+}

From 07557c6a3947471c25ff9185fd9363a7ff6b032d Mon Sep 17 00:00:00 2001
From: Jerome Romualdez <jerome.romualdez@scale.com>
Date: Thu, 9 Jul 2026 11:21:02 -0400
Subject: [PATCH 2/5] feat(schedules): support skipped runs and task counts

Expose task-backed run counts and exact skip/unskip operations so schedule clients can reason about individual future occurrences.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 agentex-ui/hooks/use-agent-run-schedules.ts   |  82 +++++++--
 agentex-ui/lib/agent-run-schedules.ts         |  32 ++++
 agentex-ui/lib/schedule-utils.test.ts         |   2 +
 agentex/openapi.yaml                          | 116 +++++++++++++
 .../src/adapters/temporal/adapter_temporal.py | 161 +++++++++++++++++-
 agentex/src/adapters/temporal/port.py         |  37 +++-
 agentex/src/api/routes/agent_run_schedules.py |  52 ++++++
 .../src/api/schemas/agent_run_schedules.py    |  24 +++
 .../domain/repositories/task_repository.py    |  17 ++
 .../services/agent_run_schedule_service.py    |  45 ++++-
 .../use_cases/agent_run_schedules_use_case.py |  15 ++
 .../api/test_agent_run_schedules_authz.py     |  23 +++
 .../test_agent_run_schedule_service.py        |  43 +++++
 13 files changed, 630 insertions(+), 19 deletions(-)

diff --git a/agentex-ui/hooks/use-agent-run-schedules.ts b/agentex-ui/hooks/use-agent-run-schedules.ts
index 8d678b3c..41b8f2f5 100644
--- a/agentex-ui/hooks/use-agent-run-schedules.ts
+++ b/agentex-ui/hooks/use-agent-run-schedules.ts
@@ -13,6 +13,8 @@ import {
   type UpdateAgentRunScheduleRequest,
 } from '@/lib/agent-run-schedules';
 
+import type { Agent } from 'agentex/resources';
+
 export const scheduleKeys = {
   all: ['agentRunSchedules'] as const,
   byAgentId: (agentId: string | null) =>
@@ -28,6 +30,18 @@ type ScheduleMutationContext = {
   agentId: string;
 };
 
+type ScheduleActionInput =
+  | string
+  | {
+      scheduleId: string;
+      scheduledTime?: string;
+    };
+
+export type AgentRunScheduleListItem = {
+  agentId: string;
+  schedule: AgentRunSchedule;
+};
+
 function errorMessage(error: unknown) {
   return error instanceof Error ? error.message : 'Please try again.';
 }
@@ -46,21 +60,33 @@ export function useAgentRunSchedules(baseURL: string, agentId: string | null) {
   });
 }
 
-export function useAgentRunScheduleDetails(
+export function useAgentRunSchedulesForAgents(
+  baseURL: string,
+  agents: Agent[],
+  enabled: boolean
+) {
+  return useQueries({
+    queries: agents.map(agent => ({
+      queryKey: scheduleKeys.byAgentId(agent.id),
+      queryFn: async () => {
+        const response = await agentRunSchedulesAPI.list(baseURL, agent.id);
+        return response.run_schedules;
+      },
+      enabled,
+    })),
+  });
+}
+
+export function useAgentRunScheduleDetailsForItems(
   baseURL: string,
-  agentId: string | null,
-  schedules: AgentRunSchedule[]
+  items: AgentRunScheduleListItem[]
 ) {
   return useQueries({
-    queries:
-      agentId == null
-        ? []
-        : schedules.map(schedule => ({
-            queryKey: scheduleKeys.detail(agentId, schedule.id),
-            queryFn: () =>
-              agentRunSchedulesAPI.get(baseURL, agentId, schedule.id),
-            staleTime: 30_000,
-          })),
+    queries: items.map(({ agentId, schedule }) => ({
+      queryKey: scheduleKeys.detail(agentId, schedule.id),
+      queryFn: () => agentRunSchedulesAPI.get(baseURL, agentId, schedule.id),
+      staleTime: 30_000,
+    })),
   });
 }
 
@@ -130,16 +156,19 @@ export function useScheduleAction({
   agentId,
   action,
 }: ScheduleMutationContext & {
-  action: 'delete' | 'pause' | 'resume' | 'trigger';
+  action: 'delete' | 'pause' | 'resume' | 'skip' | 'trigger' | 'unskip';
 }) {
   const queryClient = useQueryClient();
 
   return useMutation<
     AgentRunSchedule | { id: string; message: string },
     Error,
-    string
+    ScheduleActionInput
   >({
-    mutationFn: (scheduleId: string) => {
+    mutationFn: input => {
+      const scheduleId = typeof input === 'string' ? input : input.scheduleId;
+      const scheduledTime =
+        typeof input === 'string' ? undefined : input.scheduledTime;
       switch (action) {
         case 'delete':
           return agentRunSchedulesAPI.delete(baseURL, agentId, scheduleId);
@@ -147,8 +176,25 @@ export function useScheduleAction({
           return agentRunSchedulesAPI.pause(baseURL, agentId, scheduleId);
         case 'resume':
           return agentRunSchedulesAPI.resume(baseURL, agentId, scheduleId);
+        case 'skip':
+          return agentRunSchedulesAPI.skip(
+            baseURL,
+            agentId,
+            scheduleId,
+            scheduledTime
+          );
         case 'trigger':
           return agentRunSchedulesAPI.trigger(baseURL, agentId, scheduleId);
+        case 'unskip':
+          if (!scheduledTime) {
+            throw new Error('scheduledTime is required to unskip a run');
+          }
+          return agentRunSchedulesAPI.unskip(
+            baseURL,
+            agentId,
+            scheduleId,
+            scheduledTime
+          );
       }
     },
     onSuccess: result => {
@@ -163,7 +209,11 @@ export function useScheduleAction({
       toast.success(
         action === 'trigger'
           ? 'Scheduled task triggered'
-          : `Scheduled task ${action === 'delete' ? 'deleted' : `${action}d`}`
+          : action === 'skip'
+            ? 'Scheduled run skipped'
+            : action === 'unskip'
+              ? 'Scheduled run restored'
+              : `Scheduled task ${action === 'delete' ? 'deleted' : `${action}d`}`
       );
     },
     onError: error => {
diff --git a/agentex-ui/lib/agent-run-schedules.ts b/agentex-ui/lib/agent-run-schedules.ts
index fded0e04..2e44acdb 100644
--- a/agentex-ui/lib/agent-run-schedules.ts
+++ b/agentex-ui/lib/agent-run-schedules.ts
@@ -23,8 +23,10 @@ export type AgentRunSchedule = {
   updated_at: string | null;
   state: 'ACTIVE' | 'PAUSED';
   next_action_times: string[];
+  skipped_action_times: string[];
   last_action_time: string | null;
   num_actions_taken: number;
+  num_tasks_created: number;
 };
 
 export type AgentRunScheduleListResponse = {
@@ -145,4 +147,34 @@ export const agentRunSchedulesAPI = {
       `${schedulesPath(agentId)}/${encodeURIComponent(scheduleId)}/trigger`,
       { method: 'POST' }
     ),
+
+  skip: (
+    baseURL: string,
+    agentId: string,
+    scheduleId: string,
+    scheduledTime?: string
+  ) =>
+    request<AgentRunSchedule>(
+      baseURL,
+      `${schedulesPath(agentId)}/${encodeURIComponent(scheduleId)}/skip`,
+      {
+        method: 'POST',
+        body: JSON.stringify({ scheduled_time: scheduledTime }),
+      }
+    ),
+
+  unskip: (
+    baseURL: string,
+    agentId: string,
+    scheduleId: string,
+    scheduledTime: string
+  ) =>
+    request<AgentRunSchedule>(
+      baseURL,
+      `${schedulesPath(agentId)}/${encodeURIComponent(scheduleId)}/unskip`,
+      {
+        method: 'POST',
+        body: JSON.stringify({ scheduled_time: scheduledTime }),
+      }
+    ),
 };
diff --git a/agentex-ui/lib/schedule-utils.test.ts b/agentex-ui/lib/schedule-utils.test.ts
index e8106278..9402a0d2 100644
--- a/agentex-ui/lib/schedule-utils.test.ts
+++ b/agentex-ui/lib/schedule-utils.test.ts
@@ -96,8 +96,10 @@ describe('scheduleToCadence', () => {
     updated_at: null,
     state: 'ACTIVE',
     next_action_times: [],
+    skipped_action_times: [],
     last_action_time: null,
     num_actions_taken: 0,
+    num_tasks_created: 0,
   } satisfies AgentRunSchedule;
 
   it('converts weekly cron to editable cadence config', () => {
diff --git a/agentex/openapi.yaml b/agentex/openapi.yaml
index 3948be45..3d1707df 100644
--- a/agentex/openapi.yaml
+++ b/agentex/openapi.yaml
@@ -3595,6 +3595,86 @@ paths:
             application/json:
               schema:
                 $ref: '#/components/schemas/HTTPValidationError'
+  /agents/{agent_id}/schedules/{schedule_id}/skip:
+    post:
+      tags:
+      - Schedules
+      summary: Skip Run Schedule Action
+      description: Skip a recurring fire of the schedule.
+      operationId: skip_run_schedule_action_agents__agent_id__schedules__schedule_id__skip_post
+      parameters:
+      - name: agent_id
+        in: path
+        required: true
+        schema:
+          type: string
+          title: Agent Id
+      - name: schedule_id
+        in: path
+        required: true
+        schema:
+          type: string
+          title: Schedule Id
+      requestBody:
+        content:
+          application/json:
+            schema:
+              anyOf:
+              - $ref: '#/components/schemas/SkipRunScheduleRequest'
+              - type: 'null'
+              title: Request
+      responses:
+        '200':
+          description: Successful Response
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/AgentRunScheduleResponse'
+        '422':
+          description: Validation Error
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/HTTPValidationError'
+  /agents/{agent_id}/schedules/{schedule_id}/unskip:
+    post:
+      tags:
+      - Schedules
+      summary: Unskip Run Schedule Action
+      description: Remove a skip for a recurring fire of the schedule.
+      operationId: unskip_run_schedule_action_agents__agent_id__schedules__schedule_id__unskip_post
+      parameters:
+      - name: agent_id
+        in: path
+        required: true
+        schema:
+          type: string
+          title: Agent Id
+      - name: schedule_id
+        in: path
+        required: true
+        schema:
+          type: string
+          title: Schedule Id
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/UnskipRunScheduleRequest'
+      responses:
+        '200':
+          description: Successful Response
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/AgentRunScheduleResponse'
+        '422':
+          description: Validation Error
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/HTTPValidationError'
   /agents/{agent_id}/schedules/name/{name}/pause:
     post:
       tags:
@@ -4360,6 +4440,13 @@ components:
           type: array
           title: Next Action Times
           description: Upcoming scheduled fire times.
+        skipped_action_times:
+          items:
+            type: string
+            format: date-time
+          type: array
+          title: Skipped Action Times
+          description: Skipped one-off scheduled fire times.
         last_action_time:
           anyOf:
           - type: string
@@ -4372,6 +4459,12 @@ components:
           title: Num Actions Taken
           description: Number of times the schedule has fired.
           default: 0
+        num_tasks_created:
+          type: integer
+          title: Num Tasks Created
+          description: Number of non-deleted tasks created by this schedule, including
+            manual runs.
+          default: 0
       type: object
       required:
       - id
@@ -6087,6 +6180,18 @@ components:
       required:
       - content
       title: SendMessageRequest
+    SkipRunScheduleRequest:
+      properties:
+        scheduled_time:
+          anyOf:
+          - type: string
+            format: date-time
+          - type: 'null'
+          title: Scheduled Time
+          description: Specific scheduled fire time to skip. If omitted, the next
+            fire is skipped.
+      type: object
+      title: SkipRunScheduleRequest
     Span:
       properties:
         id:
@@ -6969,6 +7074,17 @@ components:
       - name
       title: ToolResponseDelta
       description: Delta for tool response updates
+    UnskipRunScheduleRequest:
+      properties:
+        scheduled_time:
+          type: string
+          format: date-time
+          title: Scheduled Time
+          description: Specific scheduled fire time to unskip.
+      type: object
+      required:
+      - scheduled_time
+      title: UnskipRunScheduleRequest
     UpdateAgentRunScheduleRequest:
       properties:
         name:
diff --git a/agentex/src/adapters/temporal/adapter_temporal.py b/agentex/src/adapters/temporal/adapter_temporal.py
index 617e5b96..1e4e4bcf 100644
--- a/agentex/src/adapters/temporal/adapter_temporal.py
+++ b/agentex/src/adapters/temporal/adapter_temporal.py
@@ -1,5 +1,6 @@
-from datetime import timedelta
+from datetime import UTC, datetime, timedelta
 from typing import Annotated, Any
+from zoneinfo import ZoneInfo
 
 from fastapi import Depends
 from temporalio.client import (
@@ -7,11 +8,13 @@
     Schedule,
     ScheduleActionStartWorkflow,
     ScheduleAlreadyRunningError,
+    ScheduleCalendarSpec,
     ScheduleDescription,
     ScheduleHandle,
     ScheduleIntervalSpec,
     ScheduleOverlapPolicy,
     SchedulePolicy,
+    ScheduleRange,
     ScheduleSpec,
     ScheduleState,
     ScheduleUpdate,
@@ -624,6 +627,162 @@ async def trigger_schedule(self, schedule_id: str) -> None:
                 detail=str(e),
             ) from e
 
+    async def skip_next_schedule_action(
+        self, schedule_id: str, scheduled_time: datetime | None = None
+    ) -> None:
+        """
+        Add a one-off exclusion for a scheduled action time.
+        """
+        if not self.client:
+            raise TemporalConnectionError("Temporal client is not connected")
+
+        try:
+            handle = self.client.get_schedule_handle(schedule_id)
+            description = await handle.describe()
+            action_time = scheduled_time or (
+                description.info.next_action_times[0]
+                if description.info.next_action_times
+                else None
+            )
+            if action_time is None:
+                return
+            skip = self._one_off_skip_spec(
+                action_time, description.schedule.spec.time_zone_name
+            )
+
+            def _apply(input: ScheduleUpdateInput) -> ScheduleUpdate:
+                schedule = input.description.schedule
+                schedule.spec.skip = [*schedule.spec.skip, skip]
+                return ScheduleUpdate(schedule=schedule)
+
+            await handle.update(_apply)
+            logger.info(f"Skipped next action for schedule {schedule_id}")
+        except Exception as e:
+            if "not found" in str(e).lower():
+                logger.error(f"Schedule {schedule_id} not found: {e}")
+                raise TemporalScheduleNotFoundError(
+                    message=f"Schedule '{schedule_id}' not found",
+                    detail=str(e),
+                ) from e
+            logger.error(f"Failed to skip next action for schedule {schedule_id}: {e}")
+            raise TemporalScheduleError(
+                message=f"Failed to skip next action for schedule '{schedule_id}'",
+                detail=str(e),
+            ) from e
+
+    async def unskip_schedule_action(
+        self, schedule_id: str, scheduled_time: datetime
+    ) -> None:
+        """
+        Remove a one-off exclusion for a scheduled action time.
+        """
+        if not self.client:
+            raise TemporalConnectionError("Temporal client is not connected")
+
+        try:
+            handle = self.client.get_schedule_handle(schedule_id)
+            description = await handle.describe()
+            target = self._one_off_skip_spec(
+                scheduled_time, description.schedule.spec.time_zone_name
+            )
+
+            def _apply(input: ScheduleUpdateInput) -> ScheduleUpdate:
+                schedule = input.description.schedule
+                schedule.spec.skip = [
+                    skip
+                    for skip in schedule.spec.skip
+                    if not self._same_one_off_skip(skip, target)
+                ]
+                return ScheduleUpdate(schedule=schedule)
+
+            await handle.update(_apply)
+            logger.info(f"Unskipped action for schedule {schedule_id}")
+        except Exception as e:
+            if "not found" in str(e).lower():
+                logger.error(f"Schedule {schedule_id} not found: {e}")
+                raise TemporalScheduleNotFoundError(
+                    message=f"Schedule '{schedule_id}' not found",
+                    detail=str(e),
+                ) from e
+            logger.error(f"Failed to unskip action for schedule {schedule_id}: {e}")
+            raise TemporalScheduleError(
+                message=f"Failed to unskip action for schedule '{schedule_id}'",
+                detail=str(e),
+            ) from e
+
+    @staticmethod
+    def _one_off_skip_spec(
+        scheduled_time: datetime, time_zone_name: str | None
+    ) -> ScheduleCalendarSpec:
+        if time_zone_name:
+            scheduled_time = scheduled_time.astimezone(ZoneInfo(time_zone_name))
+
+        def _range(value: int) -> list[ScheduleRange]:
+            return [ScheduleRange(start=value, end=value)]
+
+        return ScheduleCalendarSpec(
+            second=_range(scheduled_time.second),
+            minute=_range(scheduled_time.minute),
+            hour=_range(scheduled_time.hour),
+            day_of_month=_range(scheduled_time.day),
+            month=_range(scheduled_time.month),
+            year=_range(scheduled_time.year),
+            # Specify all days of week so the exact date fields above decide
+            # the match regardless of Temporal/Python weekday numbering.
+            day_of_week=[ScheduleRange(start=0, end=6)],
+            comment=f"Skipped via API at {datetime.now().isoformat()}",
+        )
+
+    @staticmethod
+    def _same_one_off_skip(
+        left: ScheduleCalendarSpec, right: ScheduleCalendarSpec
+    ) -> bool:
+        fields = ("second", "minute", "hour", "day_of_month", "month", "year")
+        return all(
+            len(getattr(left, field)) == 1
+            and len(getattr(right, field)) == 1
+            and getattr(left, field)[0].start == getattr(right, field)[0].start
+            and getattr(left, field)[0].end == getattr(right, field)[0].end
+            for field in fields
+        )
+
+    @staticmethod
+    def extract_one_off_skip_times(description: ScheduleDescription) -> list[datetime]:
+        time_zone_name = description.schedule.spec.time_zone_name
+        timezone = ZoneInfo(time_zone_name) if time_zone_name else UTC
+        skipped_times: list[datetime] = []
+
+        for skip in description.schedule.spec.skip:
+            values: dict[str, int] = {}
+            for field, date_part in (
+                ("second", "second"),
+                ("minute", "minute"),
+                ("hour", "hour"),
+                ("day_of_month", "day"),
+                ("month", "month"),
+                ("year", "year"),
+            ):
+                ranges = getattr(skip, field)
+                if len(ranges) != 1 or ranges[0].start != ranges[0].end:
+                    values = {}
+                    break
+                values[date_part] = ranges[0].start
+
+            if values:
+                skipped_times.append(
+                    datetime(
+                        values["year"],
+                        values["month"],
+                        values["day"],
+                        values["hour"],
+                        values["minute"],
+                        values["second"],
+                        tzinfo=timezone,
+                    ).astimezone(UTC)
+                )
+
+        return skipped_times
+
     async def update_schedule(
         self,
         schedule_id: str,
diff --git a/agentex/src/adapters/temporal/port.py b/agentex/src/adapters/temporal/port.py
index c3da539d..97e7f73a 100644
--- a/agentex/src/adapters/temporal/port.py
+++ b/agentex/src/adapters/temporal/port.py
@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from datetime import timedelta
+from datetime import datetime, timedelta
 from typing import Any
 
 from temporalio.client import (
@@ -360,6 +360,41 @@ async def trigger_schedule(self, schedule_id: str) -> None:
         """
         pass
 
+    @abstractmethod
+    async def skip_next_schedule_action(
+        self, schedule_id: str, scheduled_time: datetime | None = None
+    ) -> None:
+        """
+        Skip a scheduled action for a schedule.
+
+        Args:
+            schedule_id: The schedule ID
+            scheduled_time: Specific scheduled fire time to skip. If omitted,
+                the next scheduled action is skipped.
+
+        Raises:
+            TemporalScheduleNotFoundError: If schedule doesn't exist
+            TemporalScheduleError: If skip fails
+        """
+        pass
+
+    @abstractmethod
+    async def unskip_schedule_action(
+        self, schedule_id: str, scheduled_time: datetime
+    ) -> None:
+        """
+        Remove a one-off skip for a scheduled action.
+
+        Args:
+            schedule_id: The schedule ID
+            scheduled_time: Specific scheduled fire time to unskip.
+
+        Raises:
+            TemporalScheduleNotFoundError: If schedule doesn't exist
+            TemporalScheduleError: If unskip fails
+        """
+        pass
+
     @abstractmethod
     async def delete_schedule(self, schedule_id: str) -> None:
         """
diff --git a/agentex/src/api/routes/agent_run_schedules.py b/agentex/src/api/routes/agent_run_schedules.py
index bfb95cc2..93aaa77c 100644
--- a/agentex/src/api/routes/agent_run_schedules.py
+++ b/agentex/src/api/routes/agent_run_schedules.py
@@ -8,6 +8,8 @@
     CreateAgentRunScheduleRequest,
     PauseRunScheduleRequest,
     ResumeRunScheduleRequest,
+    SkipRunScheduleRequest,
+    UnskipRunScheduleRequest,
     UpdateAgentRunScheduleRequest,
 )
 from src.api.schemas.authorization_types import (
@@ -271,6 +273,56 @@ async def trigger_run_schedule(
     return await run_schedules_use_case.trigger_schedule(agent_id, schedule_id)
 
 
+@router.post(
+    "/{schedule_id}/skip",
+    response_model=AgentRunScheduleResponse,
+    summary="Skip Run Schedule Action",
+    description="Skip a recurring fire of the schedule.",
+)
+async def skip_run_schedule_action(
+    agent_id: str,
+    schedule_id: str,
+    run_schedules_use_case: DAgentRunSchedulesUseCase,
+    authorization: DAuthorizationService,
+    request: SkipRunScheduleRequest | None = None,
+) -> AgentRunScheduleResponse:
+    await _check_schedule_or_collapse_to_404(
+        authorization,
+        build_run_schedule_authz_selector(agent_id, schedule_id),
+        AuthorizedOperationType.update,
+    )
+    return await run_schedules_use_case.skip_next_schedule_action(
+        agent_id,
+        schedule_id,
+        scheduled_time=request.scheduled_time if request else None,
+    )
+
+
+@router.post(
+    "/{schedule_id}/unskip",
+    response_model=AgentRunScheduleResponse,
+    summary="Unskip Run Schedule Action",
+    description="Remove a skip for a recurring fire of the schedule.",
+)
+async def unskip_run_schedule_action(
+    agent_id: str,
+    schedule_id: str,
+    run_schedules_use_case: DAgentRunSchedulesUseCase,
+    authorization: DAuthorizationService,
+    request: UnskipRunScheduleRequest,
+) -> AgentRunScheduleResponse:
+    await _check_schedule_or_collapse_to_404(
+        authorization,
+        build_run_schedule_authz_selector(agent_id, schedule_id),
+        AuthorizedOperationType.update,
+    )
+    return await run_schedules_use_case.unskip_schedule_action(
+        agent_id,
+        schedule_id,
+        scheduled_time=request.scheduled_time,
+    )
+
+
 @router.post(
     "/name/{name}/pause",
     response_model=AgentRunScheduleResponse,
diff --git a/agentex/src/api/schemas/agent_run_schedules.py b/agentex/src/api/schemas/agent_run_schedules.py
index 80d49725..da92e21d 100644
--- a/agentex/src/api/schemas/agent_run_schedules.py
+++ b/agentex/src/api/schemas/agent_run_schedules.py
@@ -151,12 +151,21 @@ class AgentRunScheduleResponse(BaseModel):
     next_action_times: list[datetime] = Field(
         default_factory=list, description="Upcoming scheduled fire times."
     )
+    skipped_action_times: list[datetime] = Field(
+        default_factory=list, description="Skipped one-off scheduled fire times."
+    )
     last_action_time: datetime | None = Field(
         None, description="When the schedule last fired."
     )
     num_actions_taken: int = Field(
         0, description="Number of times the schedule has fired."
     )
+    num_tasks_created: int = Field(
+        0,
+        description=(
+            "Number of non-deleted tasks created by this schedule, including manual runs."
+        ),
+    )
 
 
 class AgentRunScheduleListResponse(BaseModel):
@@ -236,3 +245,18 @@ class PauseRunScheduleRequest(BaseModel):
 
 class ResumeRunScheduleRequest(BaseModel):
     note: str | None = Field(None, description="Optional note explaining the resume.")
+
+
+class SkipRunScheduleRequest(BaseModel):
+    scheduled_time: datetime | None = Field(
+        None,
+        description=(
+            "Specific scheduled fire time to skip. If omitted, the next fire is skipped."
+        ),
+    )
+
+
+class UnskipRunScheduleRequest(BaseModel):
+    scheduled_time: datetime = Field(
+        ..., description="Specific scheduled fire time to unskip."
+    )
diff --git a/agentex/src/domain/repositories/task_repository.py b/agentex/src/domain/repositories/task_repository.py
index 45662015..ed3c50f6 100644
--- a/agentex/src/domain/repositories/task_repository.py
+++ b/agentex/src/domain/repositories/task_repository.py
@@ -96,6 +96,23 @@ async def list_with_join(
             relationships=relationships,
         )
 
+    async def count_by_agent_id_and_task_metadata(
+        self, *, agent_id: str, task_metadata: dict
+    ) -> int:
+        """Count non-deleted tasks for an agent matching JSONB metadata."""
+        query = (
+            select(func.count(TaskORM.id))
+            .join(TaskAgentORM, TaskORM.id == TaskAgentORM.task_id)
+            .where(
+                TaskAgentORM.agent_id == agent_id,
+                TaskORM.task_metadata.contains(task_metadata),
+                TaskORM.status != TaskStatus.DELETED,
+            )
+        )
+        async with self.start_async_db_session(allow_writes=False) as session:
+            result = await session.execute(query)
+            return result.scalar_one()
+
     async def list_cleanup_candidate_ids(
         self,
         *,
diff --git a/agentex/src/domain/services/agent_run_schedule_service.py b/agentex/src/domain/services/agent_run_schedule_service.py
index 8a65bf5d..c9a08e94 100644
--- a/agentex/src/domain/services/agent_run_schedule_service.py
+++ b/agentex/src/domain/services/agent_run_schedule_service.py
@@ -6,7 +6,7 @@
 from temporalio.client import ScheduleDescription
 
 from src.adapters.crud_store.exceptions import DuplicateItemError, ItemDoesNotExist
-from src.adapters.temporal.adapter_temporal import DTemporalAdapter
+from src.adapters.temporal.adapter_temporal import DTemporalAdapter, TemporalAdapter
 from src.adapters.temporal.exceptions import TemporalScheduleNotFoundError
 from src.api.schemas.agent_run_schedules import (
     AgentRunScheduleListResponse,
@@ -28,6 +28,7 @@
 from src.domain.repositories.agent_run_schedule_repository import (
     DAgentRunScheduleRepository,
 )
+from src.domain.repositories.task_repository import DTaskRepository
 from src.domain.services.authorization_service import DAuthorizationService
 from src.utils.ids import orm_id
 from src.utils.logging import make_logger
@@ -72,11 +73,13 @@ def __init__(
         authorization_service: DAuthorizationService,
         schedule_repository: DAgentRunScheduleRepository,
         agent_repository: DAgentRepository,
+        task_repository: DTaskRepository,
     ):
         self.temporal_adapter = temporal_adapter
         self.authorization_service = authorization_service
         self.schedule_repository = schedule_repository
         self.agent_repository = agent_repository
+        self.task_repository = task_repository
 
     async def create_schedule(
         self,
@@ -367,6 +370,34 @@ async def trigger_schedule(
         agent = await self.agent_repository.get(id=agent_id)
         return await self._to_response(row, agent=agent, temporal_id=temporal_id)
 
+    async def skip_next_schedule_action(
+        self, agent_id: str, schedule_id: str, scheduled_time: datetime | None = None
+    ) -> AgentRunScheduleResponse:
+        """Skip a recurring fire, defaulting to the next fire."""
+        row = await self.schedule_repository.get_by_agent_id_and_id_or_raise(
+            agent_id, schedule_id
+        )
+        temporal_id = build_run_schedule_temporal_id(row.id)
+        await self.temporal_adapter.skip_next_schedule_action(
+            temporal_id, scheduled_time=scheduled_time
+        )
+        agent = await self.agent_repository.get(id=agent_id)
+        return await self._to_response(row, agent=agent, temporal_id=temporal_id)
+
+    async def unskip_schedule_action(
+        self, agent_id: str, schedule_id: str, scheduled_time: datetime
+    ) -> AgentRunScheduleResponse:
+        """Remove a skipped recurring fire."""
+        row = await self.schedule_repository.get_by_agent_id_and_id_or_raise(
+            agent_id, schedule_id
+        )
+        temporal_id = build_run_schedule_temporal_id(row.id)
+        await self.temporal_adapter.unskip_schedule_action(
+            temporal_id, scheduled_time=scheduled_time
+        )
+        agent = await self.agent_repository.get(id=agent_id)
+        return await self._to_response(row, agent=agent, temporal_id=temporal_id)
+
     # -- internals ---------------------------------------------------------
 
     async def _set_paused(
@@ -416,8 +447,15 @@ async def _to_response(
 
         state = RunScheduleState.PAUSED if entity.paused else RunScheduleState.ACTIVE
         next_action_times: list[datetime] = []
+        skipped_action_times: list[datetime] = []
         last_action_time: datetime | None = None
         num_actions_taken = 0
+        num_tasks_created = (
+            await self.task_repository.count_by_agent_id_and_task_metadata(
+                agent_id=entity.agent_id,
+                task_metadata={"schedule_id": entity.id},
+            )
+        )
 
         # Live Temporal fields are best-effort and opt-in. ``include_live=False``
         # (list path) skips the describe RPC entirely and serves state from the
@@ -430,6 +468,7 @@ async def _to_response(
                 live = self._extract_live_fields(description)
                 state = live["state"]
                 next_action_times = live["next_action_times"]
+                skipped_action_times = live["skipped_action_times"]
                 last_action_time = live["last_action_time"]
                 num_actions_taken = live["num_actions_taken"]
             except Exception as exc:
@@ -463,8 +502,10 @@ async def _to_response(
             updated_at=entity.updated_at,
             state=state,
             next_action_times=next_action_times,
+            skipped_action_times=skipped_action_times,
             last_action_time=last_action_time,
             num_actions_taken=num_actions_taken,
+            num_tasks_created=num_tasks_created,
         )
 
     @staticmethod
@@ -477,6 +518,7 @@ def _extract_live_fields(description: ScheduleDescription) -> dict[str, Any]:
         next_action_times = (
             list(info.next_action_times) if info.next_action_times else []
         )
+        skipped_action_times = TemporalAdapter.extract_one_off_skip_times(description)
         last_action_time: datetime | None = None
         if getattr(info, "recent_actions", None):
             last_action = info.recent_actions[-1]
@@ -489,6 +531,7 @@ def _extract_live_fields(description: ScheduleDescription) -> dict[str, Any]:
         return {
             "state": state,
             "next_action_times": next_action_times,
+            "skipped_action_times": skipped_action_times,
             "last_action_time": last_action_time,
             "num_actions_taken": num_actions_taken,
         }
diff --git a/agentex/src/domain/use_cases/agent_run_schedules_use_case.py b/agentex/src/domain/use_cases/agent_run_schedules_use_case.py
index cda4b7bd..6f1fcf0d 100644
--- a/agentex/src/domain/use_cases/agent_run_schedules_use_case.py
+++ b/agentex/src/domain/use_cases/agent_run_schedules_use_case.py
@@ -1,3 +1,4 @@
+from datetime import datetime
 from typing import Annotated, Any
 
 from fastapi import Depends
@@ -82,6 +83,20 @@ async def trigger_schedule(
     ) -> AgentRunScheduleResponse:
         return await self.run_schedule_service.trigger_schedule(agent_id, schedule_id)
 
+    async def skip_next_schedule_action(
+        self, agent_id: str, schedule_id: str, scheduled_time: datetime | None = None
+    ) -> AgentRunScheduleResponse:
+        return await self.run_schedule_service.skip_next_schedule_action(
+            agent_id, schedule_id, scheduled_time=scheduled_time
+        )
+
+    async def unskip_schedule_action(
+        self, agent_id: str, schedule_id: str, scheduled_time: datetime
+    ) -> AgentRunScheduleResponse:
+        return await self.run_schedule_service.unskip_schedule_action(
+            agent_id, schedule_id, scheduled_time=scheduled_time
+        )
+
     async def delete_schedule(self, agent_id: str, schedule_id: str) -> str:
         return await self.run_schedule_service.delete_schedule(agent_id, schedule_id)
 
diff --git a/agentex/tests/unit/api/test_agent_run_schedules_authz.py b/agentex/tests/unit/api/test_agent_run_schedules_authz.py
index cd8bc79a..b3a55172 100644
--- a/agentex/tests/unit/api/test_agent_run_schedules_authz.py
+++ b/agentex/tests/unit/api/test_agent_run_schedules_authz.py
@@ -19,12 +19,15 @@
     list_run_schedules,
     pause_run_schedule,
     resume_run_schedule,
+    skip_run_schedule_action,
     trigger_run_schedule,
+    unskip_run_schedule_action,
     update_run_schedule,
 )
 from src.api.schemas.agent_run_schedules import (
     CreateAgentRunScheduleRequest,
     ScheduleInitialInput,
+    UnskipRunScheduleRequest,
     UpdateAgentRunScheduleRequest,
 )
 from src.api.schemas.authorization_types import (
@@ -195,6 +198,7 @@ async def test_get_denied_collapses_to_404_and_skips_use_case(self):
             (pause_run_schedule, "pause_schedule"),
             (resume_run_schedule, "resume_schedule"),
             (trigger_run_schedule, "trigger_schedule"),
+            (skip_run_schedule_action, "skip_next_schedule_action"),
         ],
     )
     async def test_mutation_routes_use_update_op(self, route, method_name):
@@ -215,6 +219,25 @@ async def test_mutation_routes_use_update_op(self, route, method_name):
         assert called["operation"] == AuthorizedOperationType.update
         getattr(use_case, method_name).assert_awaited_once()
 
+    async def test_unskip_route_uses_update_op(self):
+        authorization = MagicMock()
+        authorization.check = AsyncMock(return_value=True)
+        use_case = MagicMock()
+        use_case.unskip_schedule_action = AsyncMock(return_value=MagicMock())
+
+        await unskip_run_schedule_action(
+            agent_id="agent-1",
+            schedule_id="schedule-1",
+            run_schedules_use_case=use_case,
+            authorization=authorization,
+            request=UnskipRunScheduleRequest(scheduled_time="2026-07-09T15:00:00Z"),
+        )
+
+        called = authorization.check.await_args.kwargs
+        assert called["resource"] == AgentexResource.schedule(_authz_selector())
+        assert called["operation"] == AuthorizedOperationType.update
+        use_case.unskip_schedule_action.assert_awaited_once()
+
     async def test_update_route_uses_update_op(self):
         authorization = MagicMock()
         authorization.check = AsyncMock(return_value=True)
diff --git a/agentex/tests/unit/services/test_agent_run_schedule_service.py b/agentex/tests/unit/services/test_agent_run_schedule_service.py
index f8150666..2c12f7b9 100644
--- a/agentex/tests/unit/services/test_agent_run_schedule_service.py
+++ b/agentex/tests/unit/services/test_agent_run_schedule_service.py
@@ -1,4 +1,5 @@
 import re
+from datetime import UTC, datetime
 from unittest.mock import AsyncMock, PropertyMock
 from uuid import uuid4
 
@@ -46,11 +47,14 @@ def service():
     )
     schedule_repository = AsyncMock()
     agent_repository = AsyncMock()
+    task_repository = AsyncMock()
+    task_repository.count_by_agent_id_and_task_metadata.return_value = 0
     return AgentRunScheduleService(
         temporal_adapter=temporal_adapter,
         authorization_service=authorization_service,
         schedule_repository=schedule_repository,
         agent_repository=agent_repository,
+        task_repository=task_repository,
     )
 
 
@@ -480,6 +484,45 @@ async def test_trigger_starts_manual_workflow(self, service, agent):
         assert start_kwargs["args"] == [row.id, "manual"]
         assert start_kwargs["task_queue"] == "agentex-server"
 
+    async def test_skip_next_updates_temporal_schedule(self, service, agent):
+        row = _persisted(agent.id, _request())
+        service.schedule_repository.get_by_agent_id_and_id_or_raise.return_value = row
+        service.agent_repository.get.return_value = agent
+
+        await service.skip_next_schedule_action(agent.id, row.id)
+
+        temporal_id = build_run_schedule_temporal_id(row.id)
+        service.temporal_adapter.skip_next_schedule_action.assert_awaited_once_with(
+            temporal_id, scheduled_time=None
+        )
+
+    async def test_unskip_updates_temporal_schedule(self, service, agent):
+        row = _persisted(agent.id, _request())
+        service.schedule_repository.get_by_agent_id_and_id_or_raise.return_value = row
+        service.agent_repository.get.return_value = agent
+        scheduled_time = datetime(2026, 7, 9, 15, 0, tzinfo=UTC)
+
+        await service.unskip_schedule_action(agent.id, row.id, scheduled_time)
+
+        temporal_id = build_run_schedule_temporal_id(row.id)
+        service.temporal_adapter.unskip_schedule_action.assert_awaited_once_with(
+            temporal_id, scheduled_time=scheduled_time
+        )
+
+    async def test_response_counts_tasks_created(self, service, agent):
+        row = _persisted(agent.id, _request())
+        service.schedule_repository.get_by_agent_id_and_id_or_raise.return_value = row
+        service.agent_repository.get.return_value = agent
+        service.task_repository.count_by_agent_id_and_task_metadata.return_value = 7
+
+        response = await service.get_schedule(agent.id, row.id)
+
+        assert response.num_tasks_created == 7
+        service.task_repository.count_by_agent_id_and_task_metadata.assert_awaited_once_with(
+            agent_id=agent.id,
+            task_metadata={"schedule_id": row.id},
+        )
+
 
 @pytest.mark.unit
 class TestCadenceValidation:

From 37013e87aa809d982b0f4410efe1ecfc77caef2a Mon Sep 17 00:00:00 2001
From: Jerome Romualdez <jerome.romualdez@scale.com>
Date: Thu, 9 Jul 2026 11:21:15 -0400
Subject: [PATCH 3/5] feat(ui): polish scheduled task views

Add agent scoping, upcoming occurrence timelines, active toggles, run-now confirmation, and skipped occurrence controls to the scheduled tasks page.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 .../scheduled-tasks/scheduled-tasks-page.tsx  | 951 ++++++++++++++++--
 1 file changed, 851 insertions(+), 100 deletions(-)

diff --git a/agentex-ui/components/scheduled-tasks/scheduled-tasks-page.tsx b/agentex-ui/components/scheduled-tasks/scheduled-tasks-page.tsx
index 24886538..63bdb6e2 100644
--- a/agentex-ui/components/scheduled-tasks/scheduled-tasks-page.tsx
+++ b/agentex-ui/components/scheduled-tasks/scheduled-tasks-page.tsx
@@ -1,8 +1,19 @@
 'use client';
 
-import { useMemo, useState } from 'react';
+import { useEffect, useMemo, useRef, useState } from 'react';
 
-import { CalendarClock, Loader2, MoreHorizontal } from 'lucide-react';
+import {
+  Bot,
+  CalendarClock,
+  Clock3,
+  Loader2,
+  MoreHorizontal,
+  PauseCircle,
+  Pencil,
+  Play,
+  Trash2,
+  X,
+} from 'lucide-react';
 
 import { useAgentexClient } from '@/components/providers';
 import { Button } from '@/components/ui/button';
@@ -16,14 +27,18 @@ import {
 import { toast } from '@/components/ui/toast';
 import { useAgentByName } from '@/hooks/use-agent-by-name';
 import {
-  useAgentRunScheduleDetails,
+  useAgentRunScheduleDetailsForItems,
   useAgentRunSchedules,
+  useAgentRunSchedulesForAgents,
   useCreateAgentRunSchedule,
   useScheduleAction,
   useUpdateAgentRunSchedule,
 } from '@/hooks/use-agent-run-schedules';
 import { useAgents } from '@/hooks/use-agents';
-import { useSafeSearchParams } from '@/hooks/use-safe-search-params';
+import {
+  SearchParamKey,
+  useSafeSearchParams,
+} from '@/hooks/use-safe-search-params';
 import type { AgentRunSchedule } from '@/lib/agent-run-schedules';
 import {
   cadenceToPayload,
@@ -37,6 +52,22 @@ import {
 } from '@/lib/schedule-utils';
 import { cn } from '@/lib/utils';
 
+import type { Agent } from 'agentex/resources';
+
+type ScheduleScope = 'current' | 'all';
+type ScheduleView = 'upcoming' | 'all';
+
+type ScheduleListItem = {
+  agentId: string;
+  agentName: string;
+  schedule: AgentRunSchedule;
+};
+
+type UpcomingRunItem = ScheduleListItem & {
+  runTime: Date;
+  isSkipped: boolean;
+};
+
 const DAYS = [
   ['MON', 'Monday'],
   ['TUE', 'Tuesday'],
@@ -69,58 +100,292 @@ function getBrowserTimezone() {
   return Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
 }
 
+function getNextRun(schedule: AgentRunSchedule) {
+  const nextRun = schedule.next_action_times[0];
+  return nextRun ? new Date(nextRun) : null;
+}
+
+function getNextRunTime(schedule: AgentRunSchedule) {
+  return getNextRun(schedule)?.getTime() ?? null;
+}
+
+function getVisibleUpcomingRuns(schedule: AgentRunSchedule) {
+  const now = Date.now();
+  const runItems = [
+    ...schedule.next_action_times.map(nextRun => ({
+      runTime: new Date(nextRun),
+      isSkipped: false,
+    })),
+    ...schedule.skipped_action_times.map(skippedRun => ({
+      runTime: new Date(skippedRun),
+      isSkipped: true,
+    })),
+  ];
+  const runsByTime = new Map<string, { runTime: Date; isSkipped: boolean }>();
+
+  for (const runItem of runItems) {
+    if (runItem.runTime.getTime() >= now) {
+      const key = runItem.runTime.toISOString();
+      const existing = runsByTime.get(key);
+      runsByTime.set(key, {
+        runTime: runItem.runTime,
+        isSkipped: runItem.isSkipped || existing?.isSkipped === true,
+      });
+    }
+  }
+
+  return Array.from(runsByTime.values())
+    .sort((a, b) => a.runTime.getTime() - b.runTime.getTime())
+    .slice(0, 5);
+}
+
+function isSchedulePaused(schedule: AgentRunSchedule) {
+  return schedule.state === 'PAUSED' || schedule.paused;
+}
+
+function sortScheduleItems(items: ScheduleListItem[], view: ScheduleView) {
+  return [...items].sort((a, b) => {
+    const aNextRun = getNextRunTime(a.schedule);
+    const bNextRun = getNextRunTime(b.schedule);
+
+    if (view === 'upcoming') {
+      return (aNextRun ?? 0) - (bNextRun ?? 0);
+    }
+
+    if (aNextRun != null && bNextRun != null) {
+      return aNextRun - bNextRun;
+    }
+    if (aNextRun != null) return -1;
+    if (bNextRun != null) return 1;
+    return a.schedule.name.localeCompare(b.schedule.name);
+  });
+}
+
+function formatRunTime(date: Date) {
+  return date.toLocaleTimeString(undefined, {
+    hour: 'numeric',
+    minute: '2-digit',
+  });
+}
+
+function formatRunDateTime(date: Date) {
+  return date.toLocaleDateString(undefined, {
+    month: 'short',
+    day: 'numeric',
+    hour: 'numeric',
+    minute: '2-digit',
+  });
+}
+
+function getUpcomingGroup(date: Date) {
+  const startOfToday = new Date();
+  startOfToday.setHours(0, 0, 0, 0);
+  const startOfTomorrow = new Date(startOfToday);
+  startOfTomorrow.setDate(startOfToday.getDate() + 1);
+  const startOfDayAfterTomorrow = new Date(startOfTomorrow);
+  startOfDayAfterTomorrow.setDate(startOfTomorrow.getDate() + 1);
+
+  if (date >= startOfToday && date < startOfTomorrow) {
+    return 'Today';
+  }
+  if (date >= startOfTomorrow && date < startOfDayAfterTomorrow) {
+    return 'Tomorrow';
+  }
+  return 'Later';
+}
+
+function formatUpcomingSubtitle(date: Date) {
+  const group = getUpcomingGroup(date);
+  if (group === 'Today') {
+    return `Today, ${formatRunTime(date)}`;
+  }
+  if (group === 'Tomorrow') {
+    return `Tomorrow, ${formatRunTime(date)}`;
+  }
+  return formatRunDateTime(date);
+}
+
+function groupUpcomingRuns(items: ScheduleListItem[]) {
+  const groups = new Map<string, UpcomingRunItem[]>();
+  for (const item of items) {
+    for (const run of getVisibleUpcomingRuns(item.schedule)) {
+      const group = getUpcomingGroup(run.runTime);
+      groups.set(group, [...(groups.get(group) ?? []), { ...item, ...run }]);
+    }
+  }
+  return ['Today', 'Tomorrow', 'Later']
+    .map(label => ({
+      label,
+      items: [...(groups.get(label) ?? [])].sort(
+        (a, b) => a.runTime.getTime() - b.runTime.getTime()
+      ),
+    }))
+    .filter(group => group.items.length > 0);
+}
+
+function useCloseOnOutsideClick<T extends HTMLElement>(
+  isOpen: boolean,
+  onClose: () => void
+) {
+  const ref = useRef<T>(null);
+
+  useEffect(() => {
+    if (!isOpen) return;
+
+    const handlePointerDown = (event: PointerEvent) => {
+      if (!ref.current?.contains(event.target as Node)) {
+        onClose();
+      }
+    };
+    const handleKeyDown = (event: KeyboardEvent) => {
+      if (event.key === 'Escape') {
+        onClose();
+      }
+    };
+
+    document.addEventListener('pointerdown', handlePointerDown);
+    document.addEventListener('keydown', handleKeyDown);
+    return () => {
+      document.removeEventListener('pointerdown', handlePointerDown);
+      document.removeEventListener('keydown', handleKeyDown);
+    };
+  }, [isOpen, onClose]);
+
+  return ref;
+}
+
 export function ScheduledTasksPage() {
-  const { agentName } = useSafeSearchParams();
+  const { agentName, updateParams } = useSafeSearchParams();
   const { agentexClient, agentexAPIBaseURL } = useAgentexClient();
-  const { data: agents = [] } = useAgents(agentexClient);
+  const { data: agents = [], isLoading: agentsLoading } =
+    useAgents(agentexClient);
   const { data: agentByName } = useAgentByName(agentexClient, agentName);
+  const [scope, setScope] = useState<ScheduleScope>('current');
+  const [scheduleView, setScheduleView] = useState<ScheduleView>('upcoming');
   const selectedAgent =
     agents.find(agent => agent.name === agentName) ?? agentByName ?? null;
   const agentId = selectedAgent?.id ?? null;
 
   const schedulesQuery = useAgentRunSchedules(agentexAPIBaseURL, agentId);
-  const schedules = schedulesQuery.data ?? [];
-  const detailQueries = useAgentRunScheduleDetails(
+  const schedules = useMemo(
+    () => schedulesQuery.data ?? [],
+    [schedulesQuery.data]
+  );
+  const allScheduleQueries = useAgentRunSchedulesForAgents(
     agentexAPIBaseURL,
-    agentId,
-    schedules
+    agents,
+    scope === 'all'
+  );
+
+  const currentItems = useMemo<ScheduleListItem[]>(
+    () =>
+      selectedAgent
+        ? schedules.map(schedule => ({
+            agentId: selectedAgent.id,
+            agentName: selectedAgent.name,
+            schedule,
+          }))
+        : [],
+    [schedules, selectedAgent]
   );
-  const schedulesWithLiveFields = schedules.map((schedule, index) => {
-    const detail = detailQueries[index]?.data;
-    return detail ?? schedule;
-  });
+
+  const allItems = useMemo<ScheduleListItem[]>(
+    () =>
+      agents.flatMap((agent, index) =>
+        (allScheduleQueries[index]?.data ?? []).map(schedule => ({
+          agentId: agent.id,
+          agentName: agent.name,
+          schedule,
+        }))
+      ),
+    [agents, allScheduleQueries]
+  );
+
+  const baseItems = scope === 'all' ? allItems : currentItems;
+  const detailQueries = useAgentRunScheduleDetailsForItems(
+    agentexAPIBaseURL,
+    baseItems
+  );
+  const schedulesWithLiveFields = baseItems.map((item, index) => ({
+    ...item,
+    schedule: detailQueries[index]?.data ?? item.schedule,
+  }));
+
+  const visibleItems = useMemo(() => {
+    const scopedItems =
+      scheduleView === 'upcoming'
+        ? schedulesWithLiveFields.filter(
+            item =>
+              !isSchedulePaused(item.schedule) &&
+              getNextRunTime(item.schedule) != null
+          )
+        : schedulesWithLiveFields;
+    return sortScheduleItems(scopedItems, scheduleView);
+  }, [scheduleView, schedulesWithLiveFields]);
+
+  const isLoading =
+    scope === 'all'
+      ? agentsLoading || allScheduleQueries.some(query => query.isLoading)
+      : schedulesQuery.isLoading;
+  const error =
+    scope === 'all'
+      ? (allScheduleQueries.find(query => query.error)?.error ?? null)
+      : schedulesQuery.error;
+  const emptyMessage =
+    scheduleView === 'upcoming'
+      ? 'No upcoming scheduled runs'
+      : scope === 'all'
+        ? 'No schedules across agents yet'
+        : 'No scheduled tasks yet';
 
   return (
     <div className="flex h-full flex-1 flex-col overflow-hidden">
-      <div className="border-border flex items-center justify-between border-b px-8 py-5">
+      <div className="border-border flex flex-wrap items-center justify-between gap-4 border-b px-8 py-5">
         <div>
           <h1 className="text-foreground text-xl font-semibold">
             Scheduled Tasks
           </h1>
           <p className="text-muted-foreground text-sm">
-            {agentName
-              ? `Run ${agentName} automatically on a cadence.`
-              : 'Select an agent to schedule recurring tasks.'}
+            {scope === 'all'
+              ? 'Browse schedules across all agents.'
+              : agentName
+                ? `Run ${agentName} automatically on a cadence.`
+                : 'Select an agent to schedule recurring tasks.'}
           </p>
         </div>
+        <ScheduleScopeSelector
+          scope={scope}
+          selectedAgent={selectedAgent}
+          agents={agents}
+          onChange={setScope}
+          onSelectAgent={nextAgentName => {
+            setScope('current');
+            updateParams({ [SearchParamKey.AGENT_NAME]: nextAgentName });
+          }}
+        />
       </div>
 
       <div className="flex min-h-0 flex-1 flex-col gap-6 overflow-y-auto px-8 py-6">
-        {!selectedAgent ? (
+        {scope === 'current' && !selectedAgent ? (
           <EmptyState message="Select an agent to create scheduled tasks." />
         ) : (
           <>
-            <ScheduleComposer
-              agentId={selectedAgent.id}
-              baseURL={agentexAPIBaseURL}
-              schedules={schedules}
-            />
+            {scope === 'current' && selectedAgent && (
+              <ScheduleComposer
+                agentId={selectedAgent.id}
+                baseURL={agentexAPIBaseURL}
+                schedules={schedules}
+              />
+            )}
+            <ScheduleViewTabs view={scheduleView} onChange={setScheduleView} />
             <ScheduleList
-              agentId={selectedAgent.id}
               baseURL={agentexAPIBaseURL}
-              schedules={schedulesWithLiveFields}
-              isLoading={schedulesQuery.isLoading}
-              error={schedulesQuery.error}
+              items={visibleItems}
+              isLoading={isLoading}
+              error={error}
+              emptyMessage={emptyMessage}
+              showAgentName={scope === 'all'}
+              view={scheduleView}
             />
           </>
         )}
@@ -129,6 +394,88 @@ export function ScheduledTasksPage() {
   );
 }
 
+function ScheduleScopeSelector({
+  scope,
+  selectedAgent,
+  agents,
+  onChange,
+  onSelectAgent,
+}: {
+  scope: ScheduleScope;
+  selectedAgent: Agent | null;
+  agents: Agent[];
+  onChange: (scope: ScheduleScope) => void;
+  onSelectAgent: (agentName: string) => void;
+}) {
+  const value = scope === 'all' ? 'all' : selectedAgent?.name;
+
+  return (
+    <Select
+      {...(value ? { value } : {})}
+      onValueChange={nextValue => {
+        if (nextValue === 'all') {
+          onChange('all');
+          return;
+        }
+        onSelectAgent(nextValue);
+      }}
+    >
+      <SelectTrigger
+        className="max-w-80 min-w-64"
+        aria-label="Schedule agent scope"
+      >
+        <SelectValue placeholder="Select an agent" />
+      </SelectTrigger>
+      <SelectContent>
+        <SelectItem value="all">
+          <span className="flex items-center gap-2">
+            <CalendarClock className="size-4" />
+            All agents
+          </span>
+        </SelectItem>
+        {agents.map(agent => (
+          <SelectItem key={agent.id} value={agent.name}>
+            <span className="flex items-center gap-2">
+              <Bot className="size-4" />
+              {agent.name}
+            </span>
+          </SelectItem>
+        ))}
+      </SelectContent>
+    </Select>
+  );
+}
+
+function ScheduleViewTabs({
+  view,
+  onChange,
+}: {
+  view: ScheduleView;
+  onChange: (view: ScheduleView) => void;
+}) {
+  return (
+    <div className="mx-auto flex w-full max-w-4xl items-center justify-between gap-3">
+      <div className="border-border bg-background flex rounded-full border p-1 shadow-sm">
+        {(['upcoming', 'all'] as const).map(option => (
+          <button
+            key={option}
+            type="button"
+            onClick={() => onChange(option)}
+            className={cn(
+              'rounded-full px-3 py-1.5 text-sm transition-colors',
+              view === option
+                ? 'bg-primary text-primary-foreground'
+                : 'text-muted-foreground hover:text-foreground'
+            )}
+          >
+            {option === 'upcoming' ? 'Upcoming' : 'All Schedules'}
+          </button>
+        ))}
+      </div>
+    </div>
+  );
+}
+
 function ScheduleComposer({
   agentId,
   baseURL,
@@ -175,7 +522,7 @@ function ScheduleComposer({
           value={prompt}
           onChange={event => setPrompt(event.target.value)}
           placeholder="What should this agent do on a schedule?"
-          className="min-h-20 resize-none bg-transparent text-sm leading-6 outline-none"
+          className="min-h-20 resize-none border-0 bg-transparent text-sm leading-6 outline-none focus:border-0 focus:ring-0 focus:outline-none focus-visible:outline-none"
         />
         <div className="flex flex-wrap items-center gap-3">
           <CadenceControls cadence={cadence} onChange={setCadence} />
@@ -338,17 +685,21 @@ function TimezoneSelect({
 }
 
 function ScheduleList({
-  agentId,
   baseURL,
-  schedules,
+  items,
   isLoading,
   error,
+  emptyMessage,
+  showAgentName,
+  view,
 }: {
-  agentId: string;
   baseURL: string;
-  schedules: AgentRunSchedule[];
+  items: ScheduleListItem[];
   isLoading: boolean;
   error: Error | null;
+  emptyMessage: string;
+  showAgentName: boolean;
+  view: ScheduleView;
 }) {
   if (isLoading) {
     return (
@@ -365,107 +716,346 @@ function ScheduleList({
     );
   }
 
-  if (schedules.length === 0) {
-    return <EmptyState message="No scheduled tasks yet" />;
+  if (items.length === 0) {
+    return <EmptyState message={emptyMessage} />;
+  }
+
+  if (view === 'upcoming') {
+    return (
+      <UpcomingScheduleList
+        baseURL={baseURL}
+        items={items}
+        showAgentName={showAgentName}
+      />
+    );
   }
 
   return (
-    <section className="mx-auto grid w-full max-w-4xl gap-3">
-      {schedules.map(schedule => (
-        <ScheduleCard
-          key={schedule.id}
-          agentId={agentId}
-          baseURL={baseURL}
-          schedule={schedule}
-        />
-      ))}
+    <AllSchedulesList
+      baseURL={baseURL}
+      items={items}
+      showAgentName={showAgentName}
+    />
+  );
+}
+
+function UpcomingScheduleList({
+  baseURL,
+  items,
+  showAgentName,
+}: {
+  baseURL: string;
+  items: ScheduleListItem[];
+  showAgentName: boolean;
+}) {
+  const groupedItems = groupUpcomingRuns(items);
+
+  return (
+    <section className="mx-auto w-full max-w-4xl">
+      <div className="flex flex-col gap-6">
+        {groupedItems.map(group => (
+          <div key={group.label} className="grid grid-cols-[5rem_1fr] gap-6">
+            <div className="text-muted-foreground pt-1 text-sm font-medium">
+              {group.label}
+            </div>
+            <div className="before:bg-border relative flex flex-col gap-5 pl-8 before:absolute before:top-2 before:bottom-2 before:left-1 before:w-px">
+              {group.items.map(item => (
+                <UpcomingScheduleRow
+                  key={`${item.schedule.id}-${item.runTime.toISOString()}`}
+                  baseURL={baseURL}
+                  item={item}
+                  showAgentName={showAgentName}
+                />
+              ))}
+            </div>
+          </div>
+        ))}
+      </div>
     </section>
   );
 }
 
-function ScheduleCard({
-  agentId,
+function UpcomingScheduleRow({
   baseURL,
-  schedule,
+  item,
+  showAgentName,
 }: {
-  agentId: string;
   baseURL: string;
-  schedule: AgentRunSchedule;
+  item: UpcomingRunItem;
+  showAgentName: boolean;
 }) {
-  const [isEditing, setIsEditing] = useState(false);
-  const pause = useScheduleAction({ baseURL, agentId, action: 'pause' });
-  const resume = useScheduleAction({ baseURL, agentId, action: 'resume' });
+  const { agentId, agentName, schedule } = item;
+  const [isMenuOpen, setIsMenuOpen] = useState(false);
+  const [isRunModalOpen, setIsRunModalOpen] = useState(false);
   const trigger = useScheduleAction({ baseURL, agentId, action: 'trigger' });
-  const deleteSchedule = useScheduleAction({
+  const skip = useScheduleAction({
     baseURL,
     agentId,
-    action: 'delete',
+    action: 'skip',
+  });
+  const unskip = useScheduleAction({
+    baseURL,
+    agentId,
+    action: 'unskip',
   });
-  const isPaused = schedule.state === 'PAUSED' || schedule.paused;
-  const nextRun = schedule.next_action_times[0];
 
   return (
-    <article className="border-border bg-card rounded-2xl border p-4 shadow-sm">
-      <div className="flex items-start justify-between gap-4">
-        <div className="min-w-0">
-          <div className="flex items-center gap-2">
-            <h2 className="truncate text-sm font-semibold">{schedule.name}</h2>
-            <span
-              className={cn(
-                'rounded-full px-2 py-0.5 text-xs',
-                isPaused
-                  ? 'bg-muted text-muted-foreground'
-                  : 'bg-green-500/10 text-green-700 dark:text-green-400'
-              )}
-            >
-              {isPaused ? 'Paused' : 'Active'}
+    <div className="relative flex items-center justify-between gap-4">
+      <span className="absolute top-2 -left-8 z-10 size-2 rounded-full bg-[#7C5CFF]" />
+      <div className="min-w-0">
+        <div className="truncate text-sm font-semibold">{schedule.name}</div>
+        <div className="text-muted-foreground flex flex-wrap items-center gap-2 text-sm">
+          <span>{formatUpcomingSubtitle(item.runTime)}</span>
+          {showAgentName && <span>· {agentName}</span>}
+          {item.isSkipped && (
+            <span className="rounded-full bg-[#7C5CFF]/10 px-2 py-0.5 text-xs font-medium text-[#6F4DFF]">
+              Skipped
             </span>
-          </div>
-          <p className="text-muted-foreground mt-1 line-clamp-2 text-sm">
-            {schedule.initial_input.content}
-          </p>
-          <p className="text-muted-foreground mt-2 text-xs">
-            {describeCadence(schedule)} · {schedule.timezone}
-            {nextRun ? ` · Next run ${new Date(nextRun).toLocaleString()}` : ''}
-          </p>
+          )}
         </div>
-        <div className="flex flex-wrap justify-end gap-2">
-          <Button
-            variant="outline"
-            size="sm"
-            onClick={() => trigger.mutate(schedule.id)}
-            disabled={trigger.isPending}
-          >
-            Run Now
-          </Button>
+      </div>
+      <div className="relative flex shrink-0 items-center gap-2">
+        {item.isSkipped ? (
           <Button
             variant="outline"
             size="sm"
             onClick={() =>
-              isPaused ? resume.mutate(schedule.id) : pause.mutate(schedule.id)
+              unskip.mutate({
+                scheduleId: schedule.id,
+                scheduledTime: item.runTime.toISOString(),
+              })
             }
-            disabled={pause.isPending || resume.isPending}
+            disabled={unskip.isPending}
           >
-            {isPaused ? 'Resume' : 'Pause'}
+            Unskip
           </Button>
+        ) : (
           <Button
             variant="outline"
             size="sm"
-            onClick={() => setIsEditing(true)}
+            onClick={() => setIsRunModalOpen(true)}
           >
-            Edit
+            <Play className="size-4" />
+            Run now
           </Button>
-          <Button
-            variant="destructive"
-            size="sm"
-            onClick={() => deleteSchedule.mutate(schedule.id)}
-            disabled={deleteSchedule.isPending}
-          >
-            Delete
+        )}
+        {isRunModalOpen && (
+          <RunNowModal
+            schedule={schedule}
+            runTime={item.runTime}
+            onClose={() => setIsRunModalOpen(false)}
+            onRunNow={() => {
+              setIsRunModalOpen(false);
+              trigger.mutate(schedule.id);
+            }}
+            onRunNowAndSkip={() => {
+              setIsRunModalOpen(false);
+              void (async () => {
+                await trigger.mutateAsync(schedule.id);
+                await skip.mutateAsync({
+                  scheduleId: schedule.id,
+                  scheduledTime: item.runTime.toISOString(),
+                });
+              })().catch(() => undefined);
+            }}
+            isRunNowPending={trigger.isPending}
+            isRunNowAndSkipPending={trigger.isPending || skip.isPending}
+          />
+        )}
+        <ScheduleOverflowMenu
+          isOpen={isMenuOpen}
+          setIsOpen={setIsMenuOpen}
+          schedule={schedule}
+          baseURL={baseURL}
+          agentId={agentId}
+          includeRunNow={false}
+          scheduledTime={item.runTime.toISOString()}
+          isSkipped={item.isSkipped}
+        />
+      </div>
+    </div>
+  );
+}
+
+function RunNowModal({
+  schedule,
+  runTime,
+  onClose,
+  onRunNow,
+  onRunNowAndSkip,
+  isRunNowPending,
+  isRunNowAndSkipPending,
+}: {
+  schedule: AgentRunSchedule;
+  runTime: Date;
+  onClose: () => void;
+  onRunNow: () => void;
+  onRunNowAndSkip: () => void;
+  isRunNowPending: boolean;
+  isRunNowAndSkipPending: boolean;
+}) {
+  const runLabel = formatUpcomingSubtitle(runTime);
+
+  return (
+    <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/30 p-4">
+      <div className="bg-background w-full max-w-md rounded-2xl border p-5 shadow-xl">
+        <div className="mb-5 flex items-center justify-between gap-3">
+          <div>
+            <h2 className="text-lg font-semibold">Run task now</h2>
+            <p className="text-muted-foreground mt-1 text-sm">
+              Choose how to handle the scheduled run at {runLabel}.
+            </p>
+          </div>
+          <Button variant="ghost" size="icon" onClick={onClose}>
+            <X className="size-4" />
           </Button>
-          <MoreHorizontal className="text-muted-foreground mt-1 size-4" />
+        </div>
+
+        <div className="flex flex-col gap-2">
+          <RunNowOption
+            title="Run now"
+            description={`Runs ${schedule.name} once right now. The scheduled run at ${runLabel} still happens as planned.`}
+            onClick={onRunNow}
+            disabled={isRunNowPending}
+          />
+          <RunNowOption
+            title="Run now & skip scheduled run"
+            description={`Runs once right now and skips only the scheduled run at ${runLabel}. Future scheduled runs are unchanged.`}
+            onClick={onRunNowAndSkip}
+            disabled={isRunNowAndSkipPending}
+          />
+        </div>
+
+        <div className="mt-4 flex items-center justify-between gap-3">
+          <p className="text-muted-foreground text-xs">
+            Skipping only affects this occurrence; the schedule remains active.
+          </p>
+          <Button variant="outline" onClick={onClose}>
+            Cancel
+          </Button>
+        </div>
+      </div>
+    </div>
+  );
+}
+
+function RunNowOption({
+  title,
+  description,
+  onClick,
+  disabled,
+}: {
+  title: string;
+  description: string;
+  onClick: () => void;
+  disabled: boolean;
+}) {
+  return (
+    <button
+      type="button"
+      onClick={onClick}
+      disabled={disabled}
+      className="border-border hover:bg-muted/40 flex w-full items-start gap-3 rounded-xl border p-4 text-left transition-colors disabled:pointer-events-none disabled:opacity-60"
+    >
+      <span className="mt-0.5 flex size-9 shrink-0 items-center justify-center rounded-xl bg-[#7C5CFF]/10 text-[#6F4DFF]">
+        <Play className="size-4" />
+      </span>
+      <span>
+        <span className="block text-sm font-semibold">{title}</span>
+        <span className="text-muted-foreground mt-1 block text-sm leading-5">
+          {description}
+        </span>
+      </span>
+    </button>
+  );
+}
+
+function AllSchedulesList({
+  baseURL,
+  items,
+  showAgentName,
+}: {
+  baseURL: string;
+  items: ScheduleListItem[];
+  showAgentName: boolean;
+}) {
+  return (
+    <section className="mx-auto w-full max-w-4xl">
+      <div className="border-border overflow-visible rounded-2xl border">
+        {items.map(({ agentId, agentName, schedule }) => (
+          <ScheduleRow
+            key={schedule.id}
+            agentId={agentId}
+            agentName={agentName}
+            baseURL={baseURL}
+            schedule={schedule}
+            showAgentName={showAgentName}
+          />
+        ))}
+      </div>
+    </section>
+  );
+}
+
+function ScheduleRow({
+  agentId,
+  agentName,
+  baseURL,
+  schedule,
+  showAgentName,
+}: {
+  agentId: string;
+  agentName: string;
+  baseURL: string;
+  schedule: AgentRunSchedule;
+  showAgentName: boolean;
+}) {
+  const [isEditing, setIsEditing] = useState(false);
+  const [isMenuOpen, setIsMenuOpen] = useState(false);
+  const pause = useScheduleAction({ baseURL, agentId, action: 'pause' });
+  const resume = useScheduleAction({ baseURL, agentId, action: 'resume' });
+  const isPaused = isSchedulePaused(schedule);
+
+  return (
+    <article className="border-border/70 relative flex items-center justify-between gap-4 border-b px-4 py-3 last:border-b-0">
+      <div className="min-w-0">
+        <div className="truncate text-sm font-semibold">{schedule.name}</div>
+        <div className="text-muted-foreground truncate text-sm">
+          {describeCadence(schedule)}
+          {showAgentName ? ` · ${agentName}` : ''}
+          {` · ${schedule.num_tasks_created} runs`}
         </div>
       </div>
+      <div className="relative flex shrink-0 items-center justify-end gap-2">
+        <button
+          type="button"
+          onClick={() =>
+            isPaused ? resume.mutate(schedule.id) : pause.mutate(schedule.id)
+          }
+          disabled={pause.isPending || resume.isPending}
+          className={cn(
+            'flex h-6 w-11 items-center rounded-full p-0.5 transition-colors disabled:opacity-60',
+            isPaused ? 'bg-slate-200 dark:bg-slate-700' : 'bg-[#6F4DFF]'
+          )}
+          aria-label={isPaused ? 'Activate schedule' : 'Deactivate schedule'}
+        >
+          <span
+            className={cn(
+              'bg-background size-5 rounded-full shadow-sm transition-transform',
+              isPaused ? 'translate-x-0' : 'translate-x-5'
+            )}
+          />
+        </button>
+        <ScheduleOverflowMenu
+          isOpen={isMenuOpen}
+          setIsOpen={setIsMenuOpen}
+          schedule={schedule}
+          baseURL={baseURL}
+          agentId={agentId}
+          onEdit={() => setIsEditing(true)}
+          includeRunNow={true}
+        />
+      </div>
       {isEditing && (
         <EditScheduleModal
           agentId={agentId}
@@ -478,6 +1068,167 @@ function ScheduleCard({
   );
 }
 
+function ScheduleOverflowMenu({
+  isOpen,
+  setIsOpen,
+  schedule,
+  baseURL,
+  agentId,
+  onEdit,
+  includeRunNow,
+  scheduledTime,
+  isSkipped = false,
+}: {
+  isOpen: boolean;
+  setIsOpen: (isOpen: boolean | ((isOpen: boolean) => boolean)) => void;
+  schedule: AgentRunSchedule;
+  baseURL: string;
+  agentId: string;
+  onEdit?: () => void;
+  includeRunNow: boolean;
+  scheduledTime?: string;
+  isSkipped?: boolean;
+}) {
+  const menuRef = useCloseOnOutsideClick<HTMLDivElement>(isOpen, () =>
+    setIsOpen(false)
+  );
+  const pause = useScheduleAction({ baseURL, agentId, action: 'pause' });
+  const resume = useScheduleAction({ baseURL, agentId, action: 'resume' });
+  const skip = useScheduleAction({
+    baseURL,
+    agentId,
+    action: 'skip',
+  });
+  const unskip = useScheduleAction({
+    baseURL,
+    agentId,
+    action: 'unskip',
+  });
+  const trigger = useScheduleAction({ baseURL, agentId, action: 'trigger' });
+  const deleteSchedule = useScheduleAction({
+    baseURL,
+    agentId,
+    action: 'delete',
+  });
+  const isPaused = isSchedulePaused(schedule);
+
+  return (
+    <div ref={menuRef} className="relative">
+      <Button
+        variant="ghost"
+        size="icon"
+        onClick={() => setIsOpen(open => !open)}
+        aria-label={`Open actions for ${schedule.name}`}
+      >
+        <MoreHorizontal className="size-4" />
+      </Button>
+      {isOpen && (
+        <div className="bg-popover text-popover-foreground absolute top-10 right-0 z-50 min-w-48 rounded-md border p-1 shadow-lg">
+          {includeRunNow && (
+            <MenuButton
+              onClick={() => {
+                setIsOpen(false);
+                trigger.mutate(schedule.id);
+              }}
+              disabled={trigger.isPending}
+            >
+              <Play className="size-4" />
+              Run now
+            </MenuButton>
+          )}
+          {isSkipped ? (
+            <MenuButton
+              onClick={() => {
+                if (!scheduledTime) return;
+                setIsOpen(false);
+                unskip.mutate({ scheduleId: schedule.id, scheduledTime });
+              }}
+              disabled={unskip.isPending || !scheduledTime}
+            >
+              <Clock3 className="size-4" />
+              Unskip run
+            </MenuButton>
+          ) : (
+            <MenuButton
+              onClick={() => {
+                setIsOpen(false);
+                skip.mutate(
+                  scheduledTime
+                    ? { scheduleId: schedule.id, scheduledTime }
+                    : schedule.id
+                );
+              }}
+              disabled={skip.isPending}
+            >
+              <Play className="size-4" />
+              Skip run
+            </MenuButton>
+          )}
+          <MenuButton disabled title="Backend support needed">
+            <Clock3 className="size-4" />
+            Snooze
+          </MenuButton>
+          <MenuButton
+            onClick={() => {
+              setIsOpen(false);
+              if (isPaused) {
+                resume.mutate(schedule.id);
+              } else {
+                pause.mutate(schedule.id);
+              }
+            }}
+            disabled={pause.isPending || resume.isPending}
+          >
+            <PauseCircle className="size-4" />
+            {isPaused ? 'Resume' : 'Pause'}
+          </MenuButton>
+          {onEdit && (
+            <MenuButton
+              onClick={() => {
+                setIsOpen(false);
+                onEdit();
+              }}
+            >
+              <Pencil className="size-4" />
+              Edit
+            </MenuButton>
+          )}
+          <MenuButton
+            onClick={() => {
+              setIsOpen(false);
+              deleteSchedule.mutate(schedule.id);
+            }}
+            disabled={deleteSchedule.isPending}
+            className="text-destructive hover:text-destructive"
+          >
+            <Trash2 className="size-4" />
+            Delete
+          </MenuButton>
+        </div>
+      )}
+    </div>
+  );
+}
+
+function MenuButton({
+  children,
+  className,
+  ...props
+}: React.ButtonHTMLAttributes<HTMLButtonElement>) {
+  return (
+    <button
+      type="button"
+      className={cn(
+        'hover:bg-accent hover:text-accent-foreground flex w-full items-center gap-2 rounded-sm px-2 py-1.5 text-left text-sm disabled:pointer-events-none disabled:opacity-50',
+        className
+      )}
+      {...props}
+    >
+      {children}
+    </button>
+  );
+}
+
 function EditScheduleModal({
   agentId,
   baseURL,

From 6cf7a8e0d9ac5eb6a56f9a56c2d3ecceb6060ccc Mon Sep 17 00:00:00 2001
From: Jerome Romualdez <jerome.romualdez@scale.com>
Date: Thu, 9 Jul 2026 11:21:26 -0400
Subject: [PATCH 4/5] fix(ui): show schedule names in task nav

Use schedule metadata for scheduled-run task labels and add a calendar indicator so recurring runs are easier to recognize.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 agentex-ui/components/task-sidebar/task-button.tsx   | 11 +++++++++--
 agentex-ui/lib/task-utils.ts                         | 12 ++++++++++++
 .../activities/scheduled_agent_run_activities.py     |  2 +-
 3 files changed, 22 insertions(+), 3 deletions(-)

diff --git a/agentex-ui/components/task-sidebar/task-button.tsx b/agentex-ui/components/task-sidebar/task-button.tsx
index 19cfa4fe..8b1a0b56 100644
--- a/agentex-ui/components/task-sidebar/task-button.tsx
+++ b/agentex-ui/components/task-sidebar/task-button.tsx
@@ -1,13 +1,14 @@
 import { memo, useCallback, useMemo } from 'react';
 
 import { formatDistanceToNow } from 'date-fns';
+import { CalendarClock } from 'lucide-react';
 
 import { ResizableSidebar } from '@/components/ui/resizable-sidebar';
 import {
   SearchParamKey,
   useSafeSearchParams,
 } from '@/hooks/use-safe-search-params';
-import { createTaskName } from '@/lib/task-utils';
+import { createTaskName, isScheduledTask } from '@/lib/task-utils';
 import { cn } from '@/lib/utils';
 
 import type { TaskListResponse } from 'agentex/resources';
@@ -19,6 +20,7 @@ type TaskButtonProps = {
 function TaskButtonImpl({ task }: TaskButtonProps) {
   const { taskID, updateParams } = useSafeSearchParams();
   const taskName = createTaskName(task);
+  const scheduledTask = isScheduledTask(task);
 
   const firstAgentName = useMemo(
     () => task.agents?.[0]?.name ?? null,
@@ -64,7 +66,12 @@ function TaskButtonImpl({ task }: TaskButtonProps) {
       isSelected={taskID === task.id}
       className={cn('flex flex-col gap-1 text-left')}
     >
-      <span className="w-full truncate text-sm">{taskName}</span>
+      <span className="flex w-full items-center gap-1.5 truncate text-sm">
+        {scheduledTask && (
+          <CalendarClock className="text-muted-foreground size-3.5 shrink-0" />
+        )}
+        <span className="truncate">{taskName}</span>
+      </span>
       <div
         className={cn(
           'text-muted-foreground w-full truncate text-xs',
diff --git a/agentex-ui/lib/task-utils.ts b/agentex-ui/lib/task-utils.ts
index 648e6b64..9a6d2e7c 100644
--- a/agentex-ui/lib/task-utils.ts
+++ b/agentex-ui/lib/task-utils.ts
@@ -1,10 +1,22 @@
 import type { TaskListResponse } from 'agentex/resources';
 
+const LEGACY_SCHEDULED_MESSAGE_PREFIX = 'Scheduled Message: ';
+
+export function isScheduledTask(
+  task: TaskListResponse.TaskListResponseItem
+): boolean {
+  const scheduleId = task?.task_metadata?.schedule_id;
+  return typeof scheduleId === 'string' && scheduleId.length > 0;
+}
+
 export function createTaskName(
   task: TaskListResponse.TaskListResponseItem
 ): string {
   const displayName = task?.task_metadata?.display_name;
   if (typeof displayName === 'string' && displayName) {
+    if (isScheduledTask(task)) {
+      return displayName.replace(LEGACY_SCHEDULED_MESSAGE_PREFIX, '');
+    }
     return displayName;
   }
 
diff --git a/agentex/src/temporal/activities/scheduled_agent_run_activities.py b/agentex/src/temporal/activities/scheduled_agent_run_activities.py
index 1c0dc16b..c1c68e6b 100644
--- a/agentex/src/temporal/activities/scheduled_agent_run_activities.py
+++ b/agentex/src/temporal/activities/scheduled_agent_run_activities.py
@@ -249,7 +249,7 @@ async def launch_scheduled_agent_run(
         # caller-supplied display_name in schedule.task_metadata overrides it.
         display_fire_time = _format_fire_time(fire_id)
         task_metadata = {
-            "display_name": f"Scheduled Message: {schedule.name} · {display_fire_time}",
+            "display_name": f"{schedule.name} · {display_fire_time}",
             **(schedule.task_metadata or {}),
             "schedule_id": schedule_id,
             "scheduled_fire_id": fire_id,

From 0673c3dc8779614e8fea8bdb28120ace7ce433db Mon Sep 17 00:00:00 2001
From: Jerome Romualdez <jerome.romualdez@scale.com>
Date: Thu, 9 Jul 2026 11:27:23 -0400
Subject: [PATCH 5/5] fix(schedules): simplify scheduled task titles

Use the schedule name as the task display label and keep occurrence timing in metadata for views that need it.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 .../scheduled_agent_run_activities.py         | 23 ++++---------------
 1 file changed, 4 insertions(+), 19 deletions(-)

diff --git a/agentex/src/temporal/activities/scheduled_agent_run_activities.py b/agentex/src/temporal/activities/scheduled_agent_run_activities.py
index c1c68e6b..b1091a4a 100644
--- a/agentex/src/temporal/activities/scheduled_agent_run_activities.py
+++ b/agentex/src/temporal/activities/scheduled_agent_run_activities.py
@@ -63,26 +63,12 @@
 
 # Temporal suffixes a scheduled workflow id with the nominal fire time
 # (e.g. ``...-run-2026-06-23T15:19:00Z``). Matching the trailing ISO-8601 lets
-# the display label use the *scheduled* time, which is stable across activity
-# retries, rather than wall-clock now() (which drifts on a delayed retry).
+# product/UI code read the occurrence time without parsing Temporal ids directly.
 _NOMINAL_FIRE_TIME_RE = re.compile(
     r"(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?)$"
 )
 
 
-def _format_fire_time(fire_id: str) -> str:
-    """Format the schedule's nominal fire time for the task display name.
-
-    Falls back to the current time when ``fire_id`` carries no recognizable
-    timestamp suffix (e.g. a manually triggered fire).
-    """
-    fire_time = _extract_fire_time(fire_id)
-    if fire_time is not None:
-        parsed = datetime.fromisoformat(fire_time.replace("Z", "+00:00"))
-        return parsed.strftime("%Y-%m-%d %H:%M UTC")
-    return datetime.now(UTC).strftime("%Y-%m-%d %H:%M UTC")
-
-
 def _extract_fire_time(fire_id: str) -> str | None:
     """Extract the occurrence time encoded in a schedule/manual fire id."""
     match = _NOMINAL_FIRE_TIME_RE.search(fire_id)
@@ -245,11 +231,10 @@ async def launch_scheduled_agent_run(
         task_name = f"scheduled-run:{schedule_id}:{fire_id}"
         # Human-friendly label the UI renders for the task (it reads
         # task_metadata.display_name, never the deterministic `name` above).
-        # Templated per fire so runs are distinguishable; placed first so a
-        # caller-supplied display_name in schedule.task_metadata overrides it.
-        display_fire_time = _format_fire_time(fire_id)
+        # Keep it stable and compact; exact occurrence time is stored separately
+        # in fire_time for views that need it.
         task_metadata = {
-            "display_name": f"{schedule.name} · {display_fire_time}",
+            "display_name": schedule.name,
             **(schedule.task_metadata or {}),
             "schedule_id": schedule_id,
             "scheduled_fire_id": fire_id,