diff --git a/frontend/package.json b/frontend/package.json
index 071bc2662cd..b063414891b 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -17,6 +17,7 @@
     "@mintplex-labs/piper-tts-web": "^1.0.4",
     "@phosphor-icons/react": "^2.1.7",
     "@tremor/react": "^3.15.1",
+    "cronstrue": "^2.50.0",
     "dompurify": "^3.0.8",
     "file-saver": "^2.0.5",
     "he": "^1.2.0",
diff --git a/frontend/src/components/PrivateRoute/index.jsx b/frontend/src/components/PrivateRoute/index.jsx
index 6220ecffe4e..9cd9110526f 100644
--- a/frontend/src/components/PrivateRoute/index.jsx
+++ b/frontend/src/components/PrivateRoute/index.jsx
@@ -126,6 +126,25 @@ export function ManagerRoute({ Component }) {
   );
 }
 
+// Allows access only in single user mode — redirects to home in multi-user mode
+export function SingleUserRoute({ Component }) {
+  const { isAuthd, shouldRedirectToOnboarding, multiUserMode } =
+    useIsAuthenticated();
+  if (isAuthd === null) return <FullScreenLoader />;
+
+  if (shouldRedirectToOnboarding) {
+    return <Navigate to={paths.onboarding.home()} />;
+  }
+
+  return isAuthd && !multiUserMode ? (
+    <KeyboardShortcutWrapper>
+      <Component />
+    </KeyboardShortcutWrapper>
+  ) : (
+    <Navigate to={paths.home()} />
+  );
+}
+
 export default function PrivateRoute({ Component }) {
   const { isAuthd, shouldRedirectToOnboarding } = useIsAuthenticated();
   if (isAuthd === null) return <FullScreenLoader />;
diff --git a/frontend/src/components/SettingsSidebar/index.jsx b/frontend/src/components/SettingsSidebar/index.jsx
index e61de158d8d..13f3e745d2f 100644
--- a/frontend/src/components/SettingsSidebar/index.jsx
+++ b/frontend/src/components/SettingsSidebar/index.jsx
@@ -395,6 +395,12 @@ const SidebarOptions = ({ user = null, t }) => (
               flex: true,
               roles: ["admin"],
             },
+            {
+              btnText: "Scheduled Jobs",
+              href: paths.settings.scheduledJobs(),
+              flex: true,
+              hidden: !!user,
+            },
             {
               btnText: t("settings.api-keys"),
               href: paths.settings.apiKeys(),
diff --git a/frontend/src/hooks/usePolling.js b/frontend/src/hooks/usePolling.js
new file mode 100644
index 00000000000..76f5928141f
--- /dev/null
+++ b/frontend/src/hooks/usePolling.js
@@ -0,0 +1,52 @@
+import { useEffect, useRef } from "react";
+
+/**
+ * Polls a callback on an interval, but only while the tab is visible.
+ * Automatically pauses when the user switches away and resumes on return.
+ *
+ * @param {() => void | Promise<void>} callback - The function to invoke on each tick
+ * @param {number} intervalMs - Polling interval in milliseconds
+ * @param {boolean} [enabled=true] - When false, polling is suspended
+ */
+export default function usePolling(callback, intervalMs, enabled = true) {
+  const savedCallback = useRef(callback);
+
+  useEffect(() => {
+    savedCallback.current = callback;
+  }, [callback]);
+
+  useEffect(() => {
+    if (!enabled || !intervalMs) return;
+
+    let timerId = null;
+
+    const start = () => {
+      if (timerId) return;
+      timerId = setInterval(() => savedCallback.current(), intervalMs);
+    };
+
+    const stop = () => {
+      if (!timerId) return;
+      clearInterval(timerId);
+      timerId = null;
+    };
+
+    const handleVisibilityChange = () => {
+      if (document.visibilityState === "visible") {
+        // Fire immediately on return so the UI feels fresh, then resume interval
+        savedCallback.current();
+        start();
+      } else {
+        stop();
+      }
+    };
+
+    if (document.visibilityState === "visible") start();
+    document.addEventListener("visibilitychange", handleVisibilityChange);
+
+    return () => {
+      stop();
+      document.removeEventListener("visibilitychange", handleVisibilityChange);
+    };
+  }, [intervalMs, enabled]);
+}
diff --git a/frontend/src/main.jsx b/frontend/src/main.jsx
index 22b375b46c0..d777862708f 100644
--- a/frontend/src/main.jsx
+++ b/frontend/src/main.jsx
@@ -5,6 +5,7 @@ import App from "@/App.jsx";
 import PrivateRoute, {
   AdminRoute,
   ManagerRoute,
+  SingleUserRoute,
 } from "@/components/PrivateRoute";
 import Login from "@/pages/Login";
 import SimpleSSOPassthrough from "@/pages/Login/SSO/simple";
@@ -381,6 +382,35 @@ const router = createBrowserRouter([
           return { element: <AdminRoute Component={TelegramBotSettings} /> };
         },
       },
+      {
+        path: "/settings/scheduled-jobs",
+        lazy: async () => {
+          const { default: ScheduledJobs } = await import(
+            "@/pages/GeneralSettings/ScheduledJobs"
+          );
+          return { element: <SingleUserRoute Component={ScheduledJobs} /> };
+        },
+      },
+      {
+        path: "/settings/scheduled-jobs/:id/runs",
+        lazy: async () => {
+          const { default: ScheduledJobRuns } = await import(
+            "@/pages/GeneralSettings/ScheduledJobs/RunHistoryPage"
+          );
+          return { element: <SingleUserRoute Component={ScheduledJobRuns} /> };
+        },
+      },
+      {
+        path: "/settings/scheduled-jobs/:id/runs/:runId",
+        lazy: async () => {
+          const { default: ScheduledJobRunDetail } = await import(
+            "@/pages/GeneralSettings/ScheduledJobs/RunDetailPage"
+          );
+          return {
+            element: <SingleUserRoute Component={ScheduledJobRunDetail} />,
+          };
+        },
+      },
       // Catch-all route for 404s
       {
         path: "*",
diff --git a/frontend/src/models/scheduledJobs.js b/frontend/src/models/scheduledJobs.js
new file mode 100644
index 00000000000..a37762307ef
--- /dev/null
+++ b/frontend/src/models/scheduledJobs.js
@@ -0,0 +1,147 @@
+import { API_BASE } from "@/utils/constants";
+import { baseHeaders } from "@/utils/request";
+
+const ScheduledJobs = {
+  list: async function () {
+    return await fetch(`${API_BASE}/scheduled-jobs`, {
+      headers: baseHeaders(),
+    })
+      .then((res) => res.json())
+      .catch((e) => {
+        console.error(e);
+        return { jobs: [] };
+      });
+  },
+
+  create: async function (data) {
+    return await fetch(`${API_BASE}/scheduled-jobs/new`, {
+      method: "POST",
+      headers: baseHeaders(),
+      body: JSON.stringify(data),
+    })
+      .then((res) => res.json())
+      .catch((e) => {
+        console.error(e);
+        return { job: null, error: e.message };
+      });
+  },
+
+  get: async function (id) {
+    return await fetch(`${API_BASE}/scheduled-jobs/${id}`, {
+      headers: baseHeaders(),
+    })
+      .then((res) => res.json())
+      .catch((e) => {
+        console.error(e);
+        return { job: null };
+      });
+  },
+
+  update: async function (id, data) {
+    return await fetch(`${API_BASE}/scheduled-jobs/${id}`, {
+      method: "PUT",
+      headers: baseHeaders(),
+      body: JSON.stringify(data),
+    })
+      .then((res) => res.json())
+      .catch((e) => {
+        console.error(e);
+        return { job: null, error: e.message };
+      });
+  },
+
+  delete: async function (id) {
+    return await fetch(`${API_BASE}/scheduled-jobs/${id}`, {
+      method: "DELETE",
+      headers: baseHeaders(),
+    })
+      .then((res) => res.json())
+      .catch((e) => {
+        console.error(e);
+        return { success: false };
+      });
+  },
+
+  toggle: async function (id) {
+    return await fetch(`${API_BASE}/scheduled-jobs/${id}/toggle`, {
+      method: "POST",
+      headers: baseHeaders(),
+    })
+      .then((res) => res.json())
+      .catch((e) => {
+        console.error(e);
+        return { job: null };
+      });
+  },
+
+  trigger: async function (id) {
+    return await fetch(`${API_BASE}/scheduled-jobs/${id}/trigger`, {
+      method: "POST",
+      headers: baseHeaders(),
+    })
+      .then((res) => res.json())
+      .catch((e) => {
+        console.error(e);
+        return { success: false, error: e.message };
+      });
+  },
+
+  runs: async function (id) {
+    return await fetch(`${API_BASE}/scheduled-jobs/${id}/runs`, {
+      headers: baseHeaders(),
+    })
+      .then((res) => res.json())
+      .catch((e) => {
+        console.error(e);
+        return { runs: [] };
+      });
+  },
+
+  getRun: async function (runId) {
+    return await fetch(`${API_BASE}/scheduled-jobs/runs/${runId}`, {
+      headers: baseHeaders(),
+    })
+      .then((res) => res.json())
+      .catch((e) => {
+        console.error(e);
+        return { run: null, job: null };
+      });
+  },
+
+  markRunRead: async function (runId) {
+    return await fetch(`${API_BASE}/scheduled-jobs/runs/${runId}/read`, {
+      method: "POST",
+      headers: baseHeaders(),
+    })
+      .then((res) => res.json())
+      .catch((e) => {
+        console.error(e);
+        return { success: false };
+      });
+  },
+
+  continueInThread: async function (runId) {
+    return await fetch(`${API_BASE}/scheduled-jobs/runs/${runId}/continue`, {
+      method: "POST",
+      headers: baseHeaders(),
+    })
+      .then((res) => res.json())
+      .catch((e) => {
+        console.error(e);
+        return { workspaceSlug: null, threadSlug: null, error: e.message };
+      });
+  },
+
+  availableTools: async function () {
+    return await fetch(`${API_BASE}/scheduled-jobs/available-tools`, {
+      headers: baseHeaders(),
+    })
+      .then((res) => res.json())
+      .catch((e) => {
+        console.error(e);
+        return { tools: [] };
+      });
+  },
+};
+
+export default ScheduledJobs;
diff --git a/frontend/src/pages/GeneralSettings/ScheduledJobs/CronBuilder.jsx b/frontend/src/pages/GeneralSettings/ScheduledJobs/CronBuilder.jsx
new file mode 100644
index 00000000000..6aaacce11b9
--- /dev/null
+++ b/frontend/src/pages/GeneralSettings/ScheduledJobs/CronBuilder.jsx
@@ -0,0 +1,181 @@
+import { useState } from "react";
+import {
+  parseCronToBuilderState,
+  buildCronFromBuilderState,
+} from "./utils/cron";
+
+const WEEKDAYS = [
+  { value: 0, label: "Sun" },
+  { value: 1, label: "Mon" },
+  { value: 2, label: "Tue" },
+  { value: 3, label: "Wed" },
+  { value: 4, label: "Thu" },
+  { value: 5, label: "Fri" },
+  { value: 6, label: "Sat" },
+];
+
+const MINUTE_INTERVALS = [1, 2, 5, 10, 15, 20, 30];
+const MINUTES = Array.from({ length: 60 }, (_, i) => i);
+const DAYS_OF_MONTH = Array.from({ length: 31 }, (_, i) => i + 1);
+
+const pad2 = (n) => String(n).padStart(2, "0");
+
+const inputClass =
+  "border-none bg-theme-settings-input-bg text-theme-text-primary text-sm rounded-lg focus:outline-primary-button outline-none p-2.5";
+
+const labelClass = "text-sm text-theme-text-secondary";
+
+// Visual cron builder. Maintains its own state derived from the incoming
+// `value` on mount, and emits a fresh 5-field cron string via `onChange`
+// whenever the user changes any sub-field.
+export default function CronBuilder({ value, onChange }) {
+  const [state, setState] = useState(
+    () => parseCronToBuilderState(value).state
+  );
+  const [wasFallback, setWasFallback] = useState(
+    () => parseCronToBuilderState(value).wasFallback
+  );
+
+  const update = (patch) => {
+    const next = { ...state, ...patch };
+    setState(next);
+    if (wasFallback) setWasFallback(false);
+    const cron = buildCronFromBuilderState(next);
+    if (cron !== value) onChange(cron);
+  };
+
+  return (
+    <div className="flex flex-col gap-3 p-3 bg-theme-settings-input-bg/40 rounded-lg">
+      {wasFallback && (
+        <p className="text-xs text-yellow-400">
+          This expression can&apos;t be edited visually. Switch to Custom to
+          keep it, or change anything below to overwrite it.
+        </p>
+      )}
+
+      <div className="flex items-center gap-2 flex-wrap">
+        <span className={labelClass}>Run</span>
+        <select
+          value={state.frequency}
+          onChange={(e) => update({ frequency: e.target.value })}
+          className={inputClass}
+        >
+          <option value="minute">every minute</option>
+          <option value="hour">hourly</option>
+          <option value="day">daily</option>
+          <option value="week">weekly</option>
+          <option value="month">monthly</option>
+        </select>
+      </div>
+
+      {state.frequency === "minute" && (
+        <div className="flex items-center gap-2 flex-wrap">
+          <span className={labelClass}>Every</span>
+          <select
+            value={state.minuteInterval}
+            onChange={(e) =>
+              update({ minuteInterval: parseInt(e.target.value, 10) })
+            }
+            className={inputClass}
+          >
+            {MINUTE_INTERVALS.map((n) => (
+              <option key={n} value={n}>
+                {n === 1 ? "1 minute" : `${n} minutes`}
+              </option>
+            ))}
+          </select>
+        </div>
+      )}
+
+      {state.frequency === "hour" && (
+        <div className="flex items-center gap-2 flex-wrap">
+          <span className={labelClass}>At minute</span>
+          <select
+            value={state.hourMinuteOffset}
+            onChange={(e) =>
+              update({ hourMinuteOffset: parseInt(e.target.value, 10) })
+            }
+            className={inputClass}
+          >
+            {MINUTES.map((n) => (
+              <option key={n} value={n}>
+                {pad2(n)}
+              </option>
+            ))}
+          </select>
+          <span className={labelClass}>past every hour</span>
+        </div>
+      )}
+
+      {(state.frequency === "day" ||
+        state.frequency === "week" ||
+        state.frequency === "month") && (
+        <div className="flex items-center gap-2 flex-wrap">
+          <span className={labelClass}>At</span>
+          <input
+            type="time"
+            value={`${pad2(state.hour)}:${pad2(state.minute)}`}
+            onChange={(e) => {
+              const [h, m] = e.target.value.split(":");
+              update({
+                hour: parseInt(h, 10) || 0,
+                minute: parseInt(m, 10) || 0,
+              });
+            }}
+            className={inputClass}
+          />
+        </div>
+      )}
+
+      {state.frequency === "week" && (
+        <div className="flex items-center gap-2 flex-wrap">
+          <span className={labelClass}>On</span>
+          <div className="flex gap-1 flex-wrap">
+            {WEEKDAYS.map((day) => {
+              const selected = state.weekdays.includes(day.value);
+              return (
+                <button
+                  key={day.value}
+                  type="button"
+                  onClick={() => {
+                    const next = selected
+                      ? state.weekdays.filter((d) => d !== day.value)
+                      : [...state.weekdays, day.value];
+                    update({ weekdays: next.length ? next : [day.value] });
+                  }}
+                  className={`px-3 py-1 text-xs rounded-full border transition-colors ${
+                    selected
+                      ? "bg-primary-button text-white border-primary-button"
+                      : "bg-transparent text-theme-text-secondary border-white/10 hover:border-white/30"
+                  }`}
+                >
+                  {day.label}
+                </button>
+              );
+            })}
+          </div>
+        </div>
+      )}
+
+      {state.frequency === "month" && (
+        <div className="flex items-center gap-2 flex-wrap">
+          <span className={labelClass}>On day</span>
+          <select
+            value={state.dayOfMonth}
+            onChange={(e) =>
+              update({ dayOfMonth: parseInt(e.target.value, 10) })
+            }
+            className={inputClass}
+          >
+            {DAYS_OF_MONTH.map((n) => (
+              <option key={n} value={n}>
+                {n}
+              </option>
+            ))}
+          </select>
+          <span className={labelClass}>of every month</span>
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/frontend/src/pages/GeneralSettings/ScheduledJobs/NewJobModal.jsx b/frontend/src/pages/GeneralSettings/ScheduledJobs/NewJobModal.jsx
new file mode 100644
index 00000000000..042a345ea35
--- /dev/null
+++ b/frontend/src/pages/GeneralSettings/ScheduledJobs/NewJobModal.jsx
@@ -0,0 +1,242 @@
+import { useState, useEffect } from "react";
+import { X } from "@phosphor-icons/react";
+import ScheduledJobs from "@/models/scheduledJobs";
+import showToast from "@/utils/toast";
+import { safeJsonParse } from "@/utils/request";
+import { humanizeCron } from "./utils/cron";
+import CronBuilder from "./CronBuilder";
+
+export default function NewJobModal({ job = null, onClose, onSaved }) {
+  const isEditing = !!job;
+  const [form, setForm] = useState({
+    name: job?.name || "",
+    prompt: job?.prompt || "",
+    schedule: job?.schedule || "0 9 * * *",
+    scheduleMode: "builder",
+    selectedTools: job?.tools ? safeJsonParse(job.tools, []) : [],
+  });
+  const [availableTools, setAvailableTools] = useState([]);
+  const [saving, setSaving] = useState(false);
+
+  useEffect(() => {
+    ScheduledJobs.availableTools().then(({ tools }) => {
+      setAvailableTools(tools || []);
+    });
+  }, []);
+
+  const handleChange = (e) => {
+    const { name, value } = e.target;
+    setForm((prev) => ({ ...prev, [name]: value }));
+  };
+
+  const handleModeChange = (mode) => {
+    setForm((prev) => ({ ...prev, scheduleMode: mode }));
+  };
+
+  const toggleTool = (toolName) => {
+    setForm((prev) => ({
+      ...prev,
+      selectedTools: prev.selectedTools.includes(toolName)
+        ? prev.selectedTools.filter((t) => t !== toolName)
+        : [...prev.selectedTools, toolName],
+    }));
+  };
+
+  const handleSubmit = async (e) => {
+    e.preventDefault();
+    if (!form.name.trim() || !form.prompt.trim() || !form.schedule.trim()) {
+      showToast("Please fill in all required fields", "error");
+      return;
+    }
+
+    setSaving(true);
+    const data = {
+      name: form.name.trim(),
+      prompt: form.prompt.trim(),
+      schedule: form.schedule.trim(),
+      tools: form.selectedTools,
+    };
+
+    const result = isEditing
+      ? await ScheduledJobs.update(job.id, data)
+      : await ScheduledJobs.create(data);
+
+    setSaving(false);
+
+    if (result.error) {
+      showToast(result.error, "error");
+      return;
+    }
+
+    showToast(isEditing ? "Job updated" : "Job created", "success");
+    onSaved();
+  };
+
+  return (
+    <div className="relative w-full max-w-2xl max-h-full">
+      <div className="relative bg-theme-bg-secondary rounded-lg shadow border border-theme-modal-border">
+        <div className="flex items-start justify-between p-4 border-b rounded-t border-theme-modal-border">
+          <h3 className="text-xl font-semibold text-theme-text-primary">
+            {isEditing ? "Edit Scheduled Job" : "New Scheduled Job"}
+          </h3>
+          <button
+            onClick={onClose}
+            type="button"
+            className="transition-all duration-300 text-gray-400 bg-transparent hover:border-white/60 rounded-lg text-sm p-1.5 ml-auto inline-flex items-center"
+          >
+            <X className="text-gray-300 text-lg" />
+          </button>
+        </div>
+
+        <form onSubmit={handleSubmit} className="p-6 space-y-6">
+          <div>
+            <label className="block mb-2 text-sm font-medium text-theme-text-primary">
+              Name <span className="text-red-400">*</span>
+            </label>
+            <input
+              type="text"
+              name="name"
+              value={form.name}
+              onChange={handleChange}
+              placeholder="e.g. Daily News Digest"
+              className="border-none bg-theme-settings-input-bg text-theme-text-primary placeholder:text-theme-settings-input-placeholder text-sm rounded-lg focus:outline-primary-button active:outline-primary-button outline-none block w-full p-2.5"
+              required
+            />
+          </div>
+
+          <div>
+            <label className="block mb-2 text-sm font-medium text-theme-text-primary">
+              Prompt <span className="text-red-400">*</span>
+            </label>
+            <textarea
+              name="prompt"
+              value={form.prompt}
+              onChange={handleChange}
+              placeholder="The instruction to run on each execution..."
+              rows={4}
+              className="border-none bg-theme-settings-input-bg text-theme-text-primary placeholder:text-theme-settings-input-placeholder text-sm rounded-lg focus:outline-primary-button active:outline-primary-button outline-none block w-full p-2.5 resize-y"
+              required
+            />
+          </div>
+
+          <div>
+            <label className="block mb-2 text-sm font-medium text-theme-text-primary">
+              Schedule <span className="text-red-400">*</span>
+            </label>
+            <div className="flex gap-1 mb-2 p-1 bg-theme-settings-input-bg rounded-lg w-fit">
+              {[
+                { value: "builder", label: "Builder" },
+                { value: "custom", label: "Custom" },
+              ].map((tab) => (
+                <button
+                  key={tab.value}
+                  type="button"
+                  onClick={() => handleModeChange(tab.value)}
+                  className={`px-3 py-1 text-xs rounded-md transition-colors ${
+                    form.scheduleMode === tab.value
+                      ? "bg-primary-button text-white"
+                      : "text-theme-text-secondary hover:text-theme-text-primary"
+                  }`}
+                >
+                  {tab.label}
+                </button>
+              ))}
+            </div>
+
+            {form.scheduleMode === "builder" && (
+              <CronBuilder
+                value={form.schedule}
+                onChange={(cron) =>
+                  setForm((prev) => ({ ...prev, schedule: cron }))
+                }
+              />
+            )}
+
+            {form.scheduleMode === "custom" && (
+              <input
+                type="text"
+                name="schedule"
+                value={form.schedule}
+                onChange={handleChange}
+                placeholder="Cron expression (e.g. 0 9 * * *)"
+                className="border-none bg-theme-settings-input-bg text-theme-text-primary placeholder:text-theme-settings-input-placeholder text-sm rounded-lg focus:outline-primary-button outline-none block w-full p-2.5"
+              />
+            )}
+
+            <p className="text-xs text-theme-text-secondary mt-2">
+              Current schedule:{" "}
+              <code className="text-theme-text-primary">{form.schedule}</code>
+              {form.schedule && (
+                <span className="ml-2">— {humanizeCron(form.schedule)}</span>
+              )}
+            </p>
+          </div>
+
+          {availableTools.length > 0 && (
+            <div>
+              <div className="flex items-center justify-between mb-1">
+                <label className="text-sm font-medium text-theme-text-primary">
+                  Tools (optional)
+                </label>
+                <button
+                  type="button"
+                  onClick={() => {
+                    const allSelected =
+                      form.selectedTools.length === availableTools.length;
+                    setForm((prev) => ({
+                      ...prev,
+                      selectedTools: allSelected
+                        ? []
+                        : availableTools.map((t) => t.id),
+                    }));
+                  }}
+                  className="px-2 py-0.5 text-xs rounded-md border border-white/10 text-theme-text-secondary hover:text-theme-text-primary hover:border-white/30 transition-colors"
+                >
+                  {form.selectedTools.length === availableTools.length
+                    ? "Deselect all"
+                    : "Select all"}
+                </button>
+              </div>
+              <p className="text-xs text-theme-text-secondary mb-2">
+                Select which agent tools this job can use.
+              </p>
+              <div className="flex flex-wrap gap-2 max-h-32 overflow-y-auto p-2 bg-theme-settings-input-bg rounded-lg">
+                {availableTools.map((tool) => (
+                  <button
+                    key={tool.id}
+                    type="button"
+                    onClick={() => toggleTool(tool.id)}
+                    className={`px-3 py-1 text-xs rounded-full border transition-colors ${
+                      form.selectedTools.includes(tool.id)
+                        ? "bg-primary-button text-white border-primary-button"
+                        : "bg-transparent text-theme-text-secondary border-white/10 hover:border-white/30"
+                    }`}
+                  >
+                    {tool.name}
+                  </button>
+                ))}
+              </div>
+            </div>
+          )}
+
+          <div className="flex justify-end gap-2 pt-4 border-t border-white/10">
+            <button
+              type="button"
+              onClick={onClose}
+              className="px-4 py-2 text-sm font-medium text-theme-text-secondary hover:text-theme-text-primary transition-colors"
+            >
+              Cancel
+            </button>
+            <button
+              type="submit"
+              disabled={saving}
+              className="px-4 py-2 text-sm font-medium text-white bg-primary-button hover:bg-secondary-btn rounded-lg transition-colors disabled:opacity-50"
+            >
+              {saving ? "Saving..." : isEditing ? "Update Job" : "Create Job"}
+            </button>
+          </div>
+        </form>
+      </div>
+    </div>
+  );
+}
diff --git a/frontend/src/pages/GeneralSettings/ScheduledJobs/RunDetailPage.jsx b/frontend/src/pages/GeneralSettings/ScheduledJobs/RunDetailPage.jsx
new file mode 100644
index 00000000000..4174d82a36c
--- /dev/null
+++ b/frontend/src/pages/GeneralSettings/ScheduledJobs/RunDetailPage.jsx
@@ -0,0 +1,293 @@
+import { useEffect, useState } from "react";
+import { useParams, useNavigate } from "react-router-dom";
+import Sidebar from "@/components/SettingsSidebar";
+import { isMobile } from "react-device-detect";
+import {
+  ArrowLeft,
+  ChatText,
+  Brain,
+  Wrench,
+  FileArrowDown,
+} from "@phosphor-icons/react";
+import ScheduledJobs from "@/models/scheduledJobs";
+import usePolling from "@/hooks/usePolling";
+import showToast from "@/utils/toast";
+import paths from "@/utils/paths";
+import renderMarkdown from "@/utils/chat/markdown";
+import CollapsibleSection from "./components/CollapsibleSection";
+import ToolCallCard from "./components/ToolCallCard";
+import GeneratedFileCard from "./components/GeneratedFileCard";
+
+const STATUS_COLORS = {
+  completed: "text-green-400",
+  failed: "text-red-400",
+  timed_out: "text-orange-400",
+  running: "text-yellow-400",
+};
+
+export default function RunDetailPage() {
+  const { id, runId } = useParams();
+  const navigate = useNavigate();
+  const [loading, setLoading] = useState(true);
+  const [run, setRun] = useState(null);
+  const [job, setJob] = useState(null);
+  const [continuing, setContinuing] = useState(false);
+
+  useEffect(() => {
+    fetchRun();
+  }, [runId]);
+
+  const fetchRun = async () => {
+    const data = await ScheduledJobs.getRun(runId);
+    setRun(data.run);
+    setJob(data.job);
+    setLoading(false);
+
+    if (data.run && !data.run.readAt) {
+      ScheduledJobs.markRunRead(runId);
+    }
+  };
+
+  // Poll every 3s while a run is in progress so the trace/status updates live.
+  // Stops automatically once the run reaches a terminal state.
+  usePolling(fetchRun, 3000, run?.status === "running");
+
+  const handleContinueInThread = async () => {
+    setContinuing(true);
+    const { workspaceSlug, threadSlug, error } =
+      await ScheduledJobs.continueInThread(runId);
+
+    if (error || !workspaceSlug || !threadSlug) {
+      showToast(error || "Failed to create thread", "error");
+      setContinuing(false);
+      return;
+    }
+
+    navigate(paths.workspace.thread(workspaceSlug, threadSlug));
+  };
+
+  const result = run?.result || {};
+
+  return (
+    <div className="w-screen h-screen overflow-hidden bg-theme-bg-container flex">
+      <Sidebar />
+      <div
+        style={{ height: isMobile ? "100%" : "calc(100% - 32px)" }}
+        className="relative md:ml-[2px] md:mr-[16px] md:my-[16px] md:rounded-[16px] bg-theme-bg-secondary w-full h-full overflow-y-scroll p-4 md:p-0"
+      >
+        <div className="flex flex-col w-full px-1 md:pl-6 md:pr-[50px] md:py-6 py-16">
+          {loading ? (
+            <p className="text-theme-text-secondary text-sm">
+              Loading run details...
+            </p>
+          ) : !run ? (
+            <p className="text-theme-text-secondary text-sm">Run not found.</p>
+          ) : (
+            <>
+              <RunHeader
+                job={job}
+                run={run}
+                result={result}
+                continuing={continuing}
+                onBack={() => navigate(`/settings/scheduled-jobs/${id}/runs`)}
+                onContinueInThread={handleContinueInThread}
+              />
+
+              <div className="mt-6 space-y-4">
+                <PromptSection prompt={job?.prompt} />
+
+                {run.error && <ErrorSection error={run.error} />}
+
+                {result.thoughts?.length && (
+                  <AgentThoughtsSection result={result} />
+                )}
+
+                {result.toolCalls?.length && (
+                  <ToolCallsSection result={result} />
+                )}
+
+                {result.generatedFiles?.length && (
+                  <GeneratedFilesSection result={result} />
+                )}
+
+                {result.text && <FinalResponseSection result={result} />}
+
+                {result.metrics && Object.keys(result.metrics).length > 0 && (
+                  <MetricsSection metrics={result.metrics} />
+                )}
+              </div>
+            </>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}
+
+function RunHeader({
+  job,
+  run,
+  result,
+  continuing,
+  onBack,
+  onContinueInThread,
+}) {
+  return (
+    <div className="w-full flex flex-col gap-y-1 pb-6 border-white/10 border-b-2">
+      <button
+        onClick={onBack}
+        className="flex items-center gap-2 text-theme-text-secondary hover:text-theme-text-primary text-sm mb-2 transition-colors w-fit"
+      >
+        <ArrowLeft className="h-4 w-4" /> Back
+      </button>
+      <div className="flex items-center justify-between">
+        <div>
+          <p className="text-lg leading-6 font-bold text-theme-text-primary">
+            {job?.name || "Unknown Job"} — Run #{run.id}
+          </p>
+          <div className="flex items-center gap-4 mt-1">
+            <span
+              className={`text-sm font-medium ${STATUS_COLORS[run.status] || "text-gray-400"}`}
+            >
+              {run.status?.replace("_", " ")}
+            </span>
+            <span className="text-xs text-theme-text-secondary">
+              {new Date(run.startedAt).toLocaleString()}
+            </span>
+            {result.duration && (
+              <span className="text-xs text-theme-text-secondary">
+                Duration: {(result.duration / 1000).toFixed(1)}s
+              </span>
+            )}
+          </div>
+        </div>
+        {run.status === "completed" && (
+          <button
+            onClick={onContinueInThread}
+            disabled={continuing}
+            className="flex items-center gap-2 px-4 py-2 text-sm font-medium text-white bg-primary-button hover:bg-secondary-btn rounded-lg transition-colors disabled:opacity-50"
+          >
+            <ChatText className="h-4 w-4" />
+            {continuing ? "Creating..." : "Continue in Thread"}
+          </button>
+        )}
+      </div>
+    </div>
+  );
+}
+
+function PromptSection({ prompt }) {
+  return (
+    <div className="border border-white/10 rounded-lg p-4">
+      <p className="text-xs text-theme-text-secondary mb-2 uppercase font-medium">
+        Prompt
+      </p>
+      <p className="text-sm text-theme-text-primary whitespace-pre-wrap">
+        {prompt || "—"}
+      </p>
+    </div>
+  );
+}
+
+function ErrorSection({ error }) {
+  return (
+    <div className="border border-red-500/20 rounded-lg p-4 bg-red-500/5">
+      <p className="text-xs text-red-400 mb-1 uppercase font-medium">Error</p>
+      <p className="text-sm text-red-300">{error}</p>
+    </div>
+  );
+}
+
+function AgentThoughtsSection({ result }) {
+  return (
+    <CollapsibleSection
+      title={`Thinking (${result.thoughts.length} steps)`}
+      icon={Brain}
+    >
+      <div className="space-y-2">
+        {result.thoughts.map((thought, i) => (
+          <div
+            key={i}
+            className="flex items-start gap-2 text-sm text-theme-text-secondary"
+          >
+            <span className="text-xs text-theme-text-secondary/50 mt-0.5 min-w-[20px]">
+              {i + 1}.
+            </span>
+            <span>{thought}</span>
+          </div>
+        ))}
+      </div>
+    </CollapsibleSection>
+  );
+}
+
+function ToolCallsSection({ result }) {
+  return (
+    <CollapsibleSection
+      title={`Tool Calls (${result.toolCalls.length})`}
+      icon={Wrench}
+    >
+      <div className="space-y-3">
+        {result.toolCalls.map((toolCall, i) => (
+          <ToolCallCard key={i} toolCall={toolCall} />
+        ))}
+      </div>
+    </CollapsibleSection>
+  );
+}
+
+function GeneratedFilesSection({ result }) {
+  return (
+    <CollapsibleSection
+      title={`Generated Documents (${result.generatedFiles.length})`}
+      icon={FileArrowDown}
+      defaultOpen={true}
+    >
+      <div className="space-y-2">
+        {result.generatedFiles.map((file, i) => (
+          <GeneratedFileCard key={i} file={file} />
+        ))}
+      </div>
+    </CollapsibleSection>
+  );
+}
+
+function FinalResponseSection({ result }) {
+  return (
+    <CollapsibleSection title="Response" icon={ChatText} defaultOpen={true}>
+      <div
+        className="text-sm text-theme-text-primary markdown"
+        dangerouslySetInnerHTML={{
+          __html: renderMarkdown(result.text),
+        }}
+      />
+    </CollapsibleSection>
+  );
+}
+function MetricsSection({ metrics }) {
+  return (
+    <div className="border border-white/10 rounded-lg p-4">
+      <p className="text-xs text-theme-text-secondary mb-2 uppercase font-medium">
+        Metrics
+      </p>
+      <div className="flex gap-6 text-xs text-theme-text-secondary">
+        {metrics.prompt_tokens != null && (
+          <span>
+            Prompt tokens:{" "}
+            <span className="text-theme-text-primary">
+              {metrics.prompt_tokens}
+            </span>
+          </span>
+        )}
+        {metrics.completion_tokens != null && (
+          <span>
+            Completion tokens:{" "}
+            <span className="text-theme-text-primary">
+              {metrics.completion_tokens}
+            </span>
+          </span>
+        )}
+      </div>
+    </div>
+  );
+}
diff --git a/frontend/src/pages/GeneralSettings/ScheduledJobs/RunHistoryPage.jsx b/frontend/src/pages/GeneralSettings/ScheduledJobs/RunHistoryPage.jsx
new file mode 100644
index 00000000000..992b66eaacd
--- /dev/null
+++ b/frontend/src/pages/GeneralSettings/ScheduledJobs/RunHistoryPage.jsx
@@ -0,0 +1,91 @@
+import { useEffect, useState } from "react";
+import { useParams, useNavigate } from "react-router-dom";
+import Sidebar from "@/components/SettingsSidebar";
+import { isMobile } from "react-device-detect";
+import { ArrowLeft } from "@phosphor-icons/react";
+import ScheduledJobs from "@/models/scheduledJobs";
+import usePolling from "@/hooks/usePolling";
+import paths from "@/utils/paths";
+import RunRow from "./components/RunRow";
+
+export default function RunHistoryPage() {
+  const { id } = useParams();
+  const navigate = useNavigate();
+  const [job, setJob] = useState(null);
+  const [runs, setRuns] = useState([]);
+  const [loading, setLoading] = useState(true);
+
+  const fetchRuns = async () => {
+    const { runs: foundRuns } = await ScheduledJobs.runs(id);
+    setRuns(foundRuns || []);
+    setLoading(false);
+  };
+
+  useEffect(() => {
+    ScheduledJobs.get(id).then(({ job }) => setJob(job));
+    fetchRuns();
+  }, [id]);
+
+  // Poll every 5s while visible so new runs appear and running statuses update.
+  usePolling(fetchRuns, 5000);
+
+  return (
+    <div className="w-screen h-screen overflow-hidden bg-theme-bg-container flex">
+      <Sidebar />
+      <div
+        style={{ height: isMobile ? "100%" : "calc(100% - 32px)" }}
+        className="relative md:ml-[2px] md:mr-[16px] md:my-[16px] md:rounded-[16px] bg-theme-bg-secondary w-full h-full overflow-y-scroll p-4 md:p-0"
+      >
+        <div className="flex flex-col w-full px-1 md:pl-6 md:pr-[50px] md:py-6 py-16">
+          <div className="w-full flex flex-col gap-y-1 pb-6 border-white/10 border-b-2">
+            <button
+              onClick={() => navigate(paths.settings.scheduledJobs())}
+              className="flex items-center gap-2 text-theme-text-secondary hover:text-theme-text-primary text-sm mb-2 transition-colors w-fit"
+            >
+              <ArrowLeft className="h-4 w-4" /> Back to jobs
+            </button>
+            <p className="text-lg leading-6 font-bold text-theme-text-primary">
+              Run History: {job?.name || "..."}
+            </p>
+            {job && (
+              <p className="text-xs text-theme-text-secondary">
+                Schedule: <code>{job.schedule}</code>
+              </p>
+            )}
+          </div>
+
+          <div className="mt-6">
+            {loading ? (
+              <div className="text-theme-text-secondary text-sm">
+                Loading...
+              </div>
+            ) : runs.length === 0 ? (
+              <div className="text-center py-12">
+                <p className="text-theme-text-secondary text-sm">
+                  No runs yet for this job.
+                </p>
+              </div>
+            ) : (
+              <table className="w-full text-sm text-left rounded-lg overflow-hidden">
+                <thead className="text-theme-text-secondary text-xs uppercase border-b border-white/10">
+                  <tr>
+                    <th className="px-6 py-3">Status</th>
+                    <th className="px-6 py-3">Started</th>
+                    <th className="px-6 py-3">Duration</th>
+                    <th className="px-6 py-3">Error</th>
+                    <th className="px-6 py-3 text-right">Actions</th>
+                  </tr>
+                </thead>
+                <tbody>
+                  {runs.map((run) => (
+                    <RunRow key={run.id} run={run} jobId={job?.id} />
+                  ))}
+                </tbody>
+              </table>
+            )}
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/frontend/src/pages/GeneralSettings/ScheduledJobs/components/CollapsibleSection.jsx b/frontend/src/pages/GeneralSettings/ScheduledJobs/components/CollapsibleSection.jsx
new file mode 100644
index 00000000000..ce564bdb1b3
--- /dev/null
+++ b/frontend/src/pages/GeneralSettings/ScheduledJobs/components/CollapsibleSection.jsx
@@ -0,0 +1,32 @@
+import { useState } from "react";
+import { CaretDown, CaretRight } from "@phosphor-icons/react";
+
+// Generic expand/collapse panel used by the run-detail page to wrap each
+// trace section (thinking, tool calls, response, generated documents).
+export default function CollapsibleSection({
+  title,
+  icon: Icon,
+  children,
+  defaultOpen = false,
+}) {
+  const [open, setOpen] = useState(defaultOpen);
+  return (
+    <div className="border border-white/10 rounded-lg overflow-hidden">
+      <button
+        onClick={() => setOpen(!open)}
+        className="w-full flex items-center gap-2 px-4 py-3 bg-theme-bg-primary/50 hover:bg-theme-bg-primary/70 transition-colors text-left"
+      >
+        {open ? (
+          <CaretDown className="h-4 w-4 text-theme-text-secondary" />
+        ) : (
+          <CaretRight className="h-4 w-4 text-theme-text-secondary" />
+        )}
+        <Icon className="h-4 w-4 text-theme-text-secondary" />
+        <span className="text-sm font-medium text-theme-text-primary">
+          {title}
+        </span>
+      </button>
+      {open && <div className="p-4 border-t border-white/10">{children}</div>}
+    </div>
+  );
+}
diff --git a/frontend/src/pages/GeneralSettings/ScheduledJobs/components/GeneratedFileCard.jsx b/frontend/src/pages/GeneralSettings/ScheduledJobs/components/GeneratedFileCard.jsx
new file mode 100644
index 00000000000..41095851604
--- /dev/null
+++ b/frontend/src/pages/GeneralSettings/ScheduledJobs/components/GeneratedFileCard.jsx
@@ -0,0 +1,125 @@
+import { useState } from "react";
+import { CircleNotch, DownloadSimple } from "@phosphor-icons/react";
+import StorageFiles from "@/models/files";
+import showToast from "@/utils/toast";
+
+// File extension → display badge/colors. Lifted out of RunDetailPage with
+// the file card itself; nothing else uses this map so it lives here.
+const FILE_DISPLAY_MAP = {
+  pptx: {
+    badge: "PPT",
+    bg: "bg-orange-100",
+    text: "text-orange-700",
+    type: "PowerPoint",
+  },
+  ppt: {
+    badge: "PPT",
+    bg: "bg-orange-100",
+    text: "text-orange-700",
+    type: "PowerPoint",
+  },
+  pdf: {
+    badge: "PDF",
+    bg: "bg-red-100",
+    text: "text-red-700",
+    type: "PDF Document",
+  },
+  doc: {
+    badge: "DOC",
+    bg: "bg-blue-100",
+    text: "text-blue-700",
+    type: "Word Document",
+  },
+  docx: {
+    badge: "DOC",
+    bg: "bg-blue-100",
+    text: "text-blue-700",
+    type: "Word Document",
+  },
+  xls: {
+    badge: "XLS",
+    bg: "bg-green-100",
+    text: "text-green-700",
+    type: "Spreadsheet",
+  },
+  xlsx: {
+    badge: "XLS",
+    bg: "bg-green-100",
+    text: "text-green-700",
+    type: "Spreadsheet",
+  },
+  csv: {
+    badge: "CSV",
+    bg: "bg-green-100",
+    text: "text-green-700",
+    type: "Spreadsheet",
+  },
+};
+
+function getFileDisplayInfo(filename) {
+  const extension = filename?.split(".")?.pop()?.toLowerCase() ?? "txt";
+  return (
+    FILE_DISPLAY_MAP[extension] || {
+      badge: extension.toUpperCase().slice(0, 4),
+      bg: "bg-slate-200",
+      text: "text-slate-700",
+      type: "File",
+    }
+  );
+}
+
+// Card representing a file generated by a job run. Streams the file from
+// the storage API on download via dynamic import of file-saver.
+export default function GeneratedFileCard({ file }) {
+  const [downloading, setDownloading] = useState(false);
+  const { badge, bg, text, type } = getFileDisplayInfo(file.filename);
+
+  const handleDownload = async () => {
+    if (downloading || !file.storageFilename) return;
+    setDownloading(true);
+    try {
+      const blob = await StorageFiles.download(file.storageFilename);
+      if (!blob) throw new Error("Failed to download file");
+      const { saveAs } = await import("file-saver");
+      saveAs(blob, file.filename || file.storageFilename);
+    } catch {
+      showToast("Failed to download file", "error");
+    } finally {
+      setDownloading(false);
+    }
+  };
+
+  return (
+    <div className="flex items-center justify-between border border-white/5 rounded-lg p-3 bg-theme-bg-primary/30">
+      <div className="flex items-center gap-3 min-w-0">
+        <div
+          className={`${bg} ${text} rounded-lg flex items-center justify-center flex-shrink-0 h-10 w-10 text-xs font-bold`}
+        >
+          {badge}
+        </div>
+        <div className="flex flex-col min-w-0">
+          <p className="text-sm font-medium text-theme-text-primary truncate">
+            {file.filename || "Unknown file"}
+          </p>
+          <p className="text-xs text-theme-text-secondary">
+            {file.fileSize ? `${(file.fileSize / 1024).toFixed(1)} KB` : ""}
+            {file.fileSize && type ? " · " : ""}
+            {type}
+          </p>
+        </div>
+      </div>
+      <button
+        onClick={handleDownload}
+        disabled={downloading}
+        className="flex items-center gap-2 px-3 py-1.5 rounded-lg border border-white/10 hover:bg-theme-bg-primary/70 transition-colors text-sm text-theme-text-primary flex-shrink-0 ml-4 disabled:opacity-50"
+      >
+        {downloading ? (
+          <CircleNotch size={14} weight="bold" className="animate-spin" />
+        ) : (
+          <DownloadSimple size={14} weight="bold" />
+        )}
+        {downloading ? "Downloading..." : "Download"}
+      </button>
+    </div>
+  );
+}
diff --git a/frontend/src/pages/GeneralSettings/ScheduledJobs/components/JobRow.jsx b/frontend/src/pages/GeneralSettings/ScheduledJobs/components/JobRow.jsx
new file mode 100644
index 00000000000..7188021b07e
--- /dev/null
+++ b/frontend/src/pages/GeneralSettings/ScheduledJobs/components/JobRow.jsx
@@ -0,0 +1,85 @@
+import { useNavigate } from "react-router-dom";
+import { Eye, Play, Power, PencilSimple, Trash } from "@phosphor-icons/react";
+import { humanizeCron } from "../utils/cron";
+import StatusBadge from "./StatusBadge";
+
+// One row of the scheduled-jobs list. Owns its own action buttons and the
+// "View runs" navigation; CRUD callbacks come from the parent.
+export default function JobRow({ job, onTrigger, onToggle, onEdit, onDelete }) {
+  const navigate = useNavigate();
+  return (
+    <tr className="border-b border-white/5 hover:bg-theme-bg-primary/30">
+      <td className="px-6 py-4">
+        <div className="flex items-center gap-2">
+          <span
+            className={`w-2 h-2 rounded-full ${job.enabled ? "bg-green-400" : "bg-gray-500"}`}
+          />
+          <span className="text-theme-text-primary font-medium">
+            {job.name}
+          </span>
+        </div>
+      </td>
+      <td className="px-6 py-4 text-theme-text-secondary">
+        {humanizeCron(job.schedule)}
+      </td>
+      <td className="px-6 py-4">
+        {job.latestRun ? (
+          <StatusBadge status={job.latestRun.status} />
+        ) : (
+          <span className="text-theme-text-secondary text-xs">Never run</span>
+        )}
+      </td>
+      <td className="px-6 py-4 text-theme-text-secondary text-xs">
+        {job.lastRunAt ? new Date(job.lastRunAt).toLocaleString() : "—"}
+      </td>
+      <td className="px-6 py-4 text-theme-text-secondary text-xs">
+        {job.enabled && job.nextRunAt
+          ? new Date(job.nextRunAt).toLocaleString()
+          : "—"}
+      </td>
+      <td className="px-6 py-4">
+        <div className="flex items-center justify-end gap-2">
+          <button
+            onClick={() => navigate(`/settings/scheduled-jobs/${job.id}/runs`)}
+            className="p-1.5 rounded-lg hover:bg-theme-bg-primary text-theme-text-secondary hover:text-theme-text-primary transition-colors"
+            title="View runs"
+          >
+            <Eye className="h-4 w-4" />
+          </button>
+          <button
+            onClick={() => onTrigger(job.id)}
+            className="p-1.5 rounded-lg hover:bg-theme-bg-primary text-theme-text-secondary hover:text-theme-text-primary transition-colors"
+            title="Run now"
+          >
+            <Play className="h-4 w-4" />
+          </button>
+          <button
+            onClick={() => onToggle(job.id)}
+            className={`p-1.5 rounded-lg hover:bg-theme-bg-primary transition-colors ${
+              job.enabled
+                ? "text-green-400 hover:text-yellow-400"
+                : "text-gray-500 hover:text-green-400"
+            }`}
+            title={job.enabled ? "Disable" : "Enable"}
+          >
+            <Power className="h-4 w-4" />
+          </button>
+          <button
+            onClick={() => onEdit(job)}
+            className="p-1.5 rounded-lg hover:bg-theme-bg-primary text-theme-text-secondary hover:text-theme-text-primary transition-colors"
+            title="Edit"
+          >
+            <PencilSimple className="h-4 w-4" />
+          </button>
+          <button
+            onClick={() => onDelete(job.id)}
+            className="p-1.5 rounded-lg hover:bg-theme-bg-primary text-theme-text-secondary hover:text-red-400 transition-colors"
+            title="Delete"
+          >
+            <Trash className="h-4 w-4" />
+          </button>
+        </div>
+      </td>
+    </tr>
+  );
+}
diff --git a/frontend/src/pages/GeneralSettings/ScheduledJobs/components/RunRow.jsx b/frontend/src/pages/GeneralSettings/ScheduledJobs/components/RunRow.jsx
new file mode 100644
index 00000000000..8a100860973
--- /dev/null
+++ b/frontend/src/pages/GeneralSettings/ScheduledJobs/components/RunRow.jsx
@@ -0,0 +1,58 @@
+import { useNavigate } from "react-router-dom";
+import { Circle, Eye } from "@phosphor-icons/react";
+import paths from "@/utils/paths";
+import StatusBadge from "./StatusBadge";
+
+// Format a run's elapsed time as ms / s / m. Only used here so it lives
+// alongside the row component.
+function formatDuration(run) {
+  if (!run.completedAt || !run.startedAt) return "—";
+  const ms =
+    new Date(run.completedAt).getTime() - new Date(run.startedAt).getTime();
+  if (ms < 1000) return `${ms}ms`;
+  if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+  return `${(ms / 60000).toFixed(1)}m`;
+}
+
+// One row of the run history table for a job. Shows status, timestamps,
+// duration, error preview, and a link to the run detail page.
+export default function RunRow({ run, jobId }) {
+  const navigate = useNavigate();
+  return (
+    <tr className="border-b border-white/5 hover:bg-theme-bg-primary/30">
+      <td className="px-6 py-4">
+        <div className="flex items-center gap-2 relative">
+          {!run.readAt && run.status !== "running" && (
+            <Circle
+              weight="fill"
+              className="h-2 w-2 text-blue-400 absolute -left-4"
+            />
+          )}
+          <StatusBadge status={run.status} />
+        </div>
+      </td>
+      <td className="px-6 py-4 text-theme-text-secondary text-xs">
+        {new Date(run.startedAt).toLocaleString()}
+      </td>
+      <td className="px-6 py-4 text-theme-text-secondary text-xs">
+        {formatDuration(run)}
+      </td>
+      <td className="px-6 py-4 text-red-400 text-xs max-w-[200px] truncate">
+        {run.error || "—"}
+      </td>
+      <td className="px-6 py-4">
+        <div className="flex items-center justify-end">
+          <button
+            onClick={() =>
+              navigate(paths.settings.scheduledJobRunDetail(jobId, run.id))
+            }
+            className="p-1.5 rounded-lg hover:bg-theme-bg-primary text-theme-text-secondary hover:text-theme-text-primary transition-colors"
+            title="View details"
+          >
+            <Eye className="h-4 w-4" />
+          </button>
+        </div>
+      </td>
+    </tr>
+  );
+}
diff --git a/frontend/src/pages/GeneralSettings/ScheduledJobs/components/StatusBadge.jsx b/frontend/src/pages/GeneralSettings/ScheduledJobs/components/StatusBadge.jsx
new file mode 100644
index 00000000000..fb48b9d1a81
--- /dev/null
+++ b/frontend/src/pages/GeneralSettings/ScheduledJobs/components/StatusBadge.jsx
@@ -0,0 +1,20 @@
+const STATUS_COLORS = {
+  running: "bg-yellow-500/20 text-yellow-400",
+  completed: "bg-green-500/20 text-green-400",
+  failed: "bg-red-500/20 text-red-400",
+  timed_out: "bg-orange-500/20 text-orange-400",
+};
+
+// Pill badge for a scheduled-job-run status. Used in the jobs list and the
+// run history table to keep the visual treatment consistent.
+export default function StatusBadge({ status }) {
+  return (
+    <span
+      className={`px-2 py-0.5 rounded-full text-xs font-medium ${
+        STATUS_COLORS[status] || "bg-gray-500/20 text-gray-400"
+      }`}
+    >
+      {status?.replace("_", " ") || "—"}
+    </span>
+  );
+}
diff --git a/frontend/src/pages/GeneralSettings/ScheduledJobs/components/ToolCallCard.jsx b/frontend/src/pages/GeneralSettings/ScheduledJobs/components/ToolCallCard.jsx
new file mode 100644
index 00000000000..b1f28615f68
--- /dev/null
+++ b/frontend/src/pages/GeneralSettings/ScheduledJobs/components/ToolCallCard.jsx
@@ -0,0 +1,108 @@
+import { useState } from "react";
+import { Wrench } from "@phosphor-icons/react";
+import hljs from "highlight.js";
+import { safeJsonParse } from "@/utils/request";
+import { useTheme } from "@/hooks/useTheme";
+
+// Helpers below are colocated because they're only used here. Lifted out
+// of RunDetailPage as part of the components refactor.
+
+function getHljsTheme(isLight) {
+  return isLight ? "github" : "github-dark";
+}
+
+function truncateText(text) {
+  return text.length > 5000 ? text.slice(0, 5000) + "..." : text;
+}
+
+// Try to render `value` as syntax-highlighted JSON. Returns a `dangerouslySetInnerHTML`
+// payload, or null if the value isn't an object (caller should fall back to plain text).
+function formatAndHighlight(value) {
+  const parsed =
+    typeof value === "string" ? safeJsonParse(value, value) : value;
+
+  if (typeof parsed === "object" && parsed !== null) {
+    const formatted = JSON.stringify(parsed, null, 2);
+    const truncatedFormatted = truncateText(formatted);
+    const highlighted = hljs.highlight(truncatedFormatted, {
+      language: "json",
+    }).value;
+    return { __html: highlighted };
+  }
+  return null;
+}
+
+// Single tool call inside the run trace. Shows the tool name, arguments, and
+// (on demand) the tool's result. JSON arguments and results are pretty-printed
+// and syntax-highlighted; non-JSON values fall back to plain text.
+export default function ToolCallCard({ toolCall }) {
+  const [showResult, setShowResult] = useState(false);
+  const { isLight } = useTheme();
+
+  const resultText =
+    typeof toolCall.result === "string"
+      ? toolCall.result
+      : JSON.stringify(toolCall.result, null, 2);
+
+  const truncatedResult = truncateText(resultText);
+  const highlightedResult = formatAndHighlight(toolCall.result);
+  const highlightedArgs = formatAndHighlight(toolCall.arguments);
+
+  return (
+    <div className="border border-white/5 rounded-lg p-3 bg-theme-bg-primary/30">
+      <div className="flex items-center justify-between mb-2">
+        <div className="flex items-center gap-2">
+          <Wrench className="h-3.5 w-3.5 text-blue-400" />
+          <span className="text-sm font-medium text-theme-text-primary">
+            {toolCall.toolName}
+          </span>
+        </div>
+        {toolCall.timestamp && (
+          <span className="text-xs text-theme-text-secondary">
+            {new Date(toolCall.timestamp).toLocaleTimeString()}
+          </span>
+        )}
+      </div>
+
+      {toolCall.arguments && (
+        <div className="mb-2">
+          <span className="text-xs text-theme-text-secondary">Arguments:</span>
+          {highlightedArgs ? (
+            <pre
+              className={`text-xs rounded-lg p-2 mt-1 overflow-x-auto white-scrollbar hljs ${getHljsTheme(isLight)}`}
+              dangerouslySetInnerHTML={highlightedArgs}
+            />
+          ) : (
+            <pre className="text-xs text-theme-text-primary bg-theme-bg-primary/50 rounded p-2 mt-1 overflow-x-auto white-scrollbar">
+              {typeof toolCall.arguments === "string"
+                ? toolCall.arguments
+                : JSON.stringify(toolCall.arguments, null, 2)}
+            </pre>
+          )}
+        </div>
+      )}
+
+      {resultText && (
+        <div>
+          <button
+            onClick={() => setShowResult(!showResult)}
+            className="text-xs text-blue-400 hover:text-blue-300 transition-colors"
+          >
+            {showResult ? "Hide result" : "Show result"}
+          </button>
+          {showResult &&
+            (highlightedResult ? (
+              <pre
+                className={`text-xs rounded-lg p-2 mt-1 overflow-x-auto max-h-64 overflow-y-auto whitespace-pre-wrap white-scrollbar hljs ${getHljsTheme(isLight)}`}
+                dangerouslySetInnerHTML={highlightedResult}
+              />
+            ) : (
+              <pre className="text-xs text-theme-text-primary bg-theme-bg-primary/50 rounded p-2 mt-1 overflow-x-auto max-h-64 overflow-y-auto whitespace-pre-wrap white-scrollbar">
+                {truncatedResult}
+              </pre>
+            ))}
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/frontend/src/pages/GeneralSettings/ScheduledJobs/index.jsx b/frontend/src/pages/GeneralSettings/ScheduledJobs/index.jsx
new file mode 100644
index 00000000000..d25ccadf6f8
--- /dev/null
+++ b/frontend/src/pages/GeneralSettings/ScheduledJobs/index.jsx
@@ -0,0 +1,146 @@
+import { useEffect, useState } from "react";
+import Sidebar from "@/components/SettingsSidebar";
+import { isMobile } from "react-device-detect";
+import { PlusCircle } from "@phosphor-icons/react";
+import ScheduledJobs from "@/models/scheduledJobs";
+import useWebPushNotifications from "@/hooks/useWebPushNotifications";
+import usePolling from "@/hooks/usePolling";
+import NewJobModal from "./NewJobModal";
+import ModalWrapper from "@/components/ModalWrapper";
+import { useModal } from "@/hooks/useModal";
+import CTAButton from "@/components/lib/CTAButton";
+import showToast from "@/utils/toast";
+import JobRow from "./components/JobRow";
+
+export default function ScheduledJobsPage() {
+  useWebPushNotifications();
+  const { isOpen, openModal, closeModal } = useModal();
+  const [loading, setLoading] = useState(true);
+  const [jobs, setJobs] = useState([]);
+  const [editingJob, setEditingJob] = useState(null);
+
+  const fetchJobs = async () => {
+    const { jobs: foundJobs } = await ScheduledJobs.list();
+    setJobs(foundJobs || []);
+    setLoading(false);
+  };
+
+  useEffect(() => {
+    fetchJobs();
+  }, []);
+
+  // Poll every 5s while tab is visible so status badges and run timestamps stay in sync.
+  usePolling(fetchJobs, 5000);
+
+  const handleDelete = async (id) => {
+    if (!window.confirm("Are you sure you want to delete this scheduled job?"))
+      return;
+    await ScheduledJobs.delete(id);
+    showToast("Job deleted", "success");
+    fetchJobs();
+  };
+
+  const handleToggle = async (id) => {
+    const result = await ScheduledJobs.toggle(id);
+    if (result?.error) {
+      showToast(result.error, "error");
+    }
+    fetchJobs();
+  };
+
+  const handleTrigger = async (id) => {
+    const { success, error } = await ScheduledJobs.trigger(id);
+    if (success) {
+      showToast("Job triggered successfully", "success");
+    } else {
+      showToast(error || "Failed to trigger job", "error");
+    }
+    fetchJobs();
+  };
+
+  const handleEdit = (job) => {
+    setEditingJob(job);
+    openModal();
+  };
+
+  const handleCreate = () => {
+    setEditingJob(null);
+    openModal();
+  };
+
+  return (
+    <div className="w-screen h-screen overflow-hidden bg-theme-bg-container flex">
+      <Sidebar />
+      <div
+        style={{ height: isMobile ? "100%" : "calc(100% - 32px)" }}
+        className="relative md:ml-[2px] md:mr-[16px] md:my-[16px] md:rounded-[16px] bg-theme-bg-secondary w-full h-full overflow-y-scroll p-4 md:p-0"
+      >
+        <div className="flex flex-col w-full px-1 md:pl-6 md:pr-[50px] md:py-6 py-16">
+          <div className="w-full flex flex-col gap-y-1 pb-6 border-white/10 border-b-2">
+            <div className="items-center flex gap-x-4">
+              <p className="text-lg leading-6 font-bold text-theme-text-primary">
+                Scheduled Jobs
+              </p>
+            </div>
+            <p className="text-xs leading-[18px] font-base text-theme-text-secondary">
+              Create recurring AI tasks that run on a schedule. Each job runs a
+              prompt with optional tools and saves the result for review.
+            </p>
+          </div>
+
+          <div className="w-full justify-end flex pt-6 pb-4">
+            <CTAButton onClick={handleCreate}>
+              <PlusCircle className="h-4 w-4" weight="bold" /> New Job
+            </CTAButton>
+          </div>
+
+          {loading ? (
+            <div className="text-theme-text-secondary text-sm">Loading...</div>
+          ) : jobs.length === 0 ? (
+            <div className="text-center py-12">
+              <p className="text-theme-text-secondary text-sm">
+                No scheduled jobs yet. Create one to get started.
+              </p>
+            </div>
+          ) : (
+            <table className="w-full text-sm text-left rounded-lg overflow-hidden">
+              <thead className="text-theme-text-secondary text-xs uppercase border-b border-white/10">
+                <tr>
+                  <th className="px-6 py-3">Name</th>
+                  <th className="px-6 py-3">Schedule</th>
+                  <th className="px-6 py-3">Status</th>
+                  <th className="px-6 py-3">Last Run</th>
+                  <th className="px-6 py-3">Next Run</th>
+                  <th className="px-6 py-3 text-right">Actions</th>
+                </tr>
+              </thead>
+              <tbody>
+                {jobs.map((job) => (
+                  <JobRow
+                    key={job.id}
+                    job={job}
+                    onTrigger={handleTrigger}
+                    onToggle={handleToggle}
+                    onEdit={handleEdit}
+                    onDelete={handleDelete}
+                  />
+                ))}
+              </tbody>
+            </table>
+          )}
+        </div>
+      </div>
+
+      <ModalWrapper isOpen={isOpen}>
+        <NewJobModal
+          job={editingJob}
+          onClose={closeModal}
+          onSaved={() => {
+            closeModal();
+            fetchJobs();
+          }}
+        />
+      </ModalWrapper>
+    </div>
+  );
+}
diff --git a/frontend/src/pages/GeneralSettings/ScheduledJobs/utils/cron.js b/frontend/src/pages/GeneralSettings/ScheduledJobs/utils/cron.js
new file mode 100644
index 00000000000..b3dcf39d610
--- /dev/null
+++ b/frontend/src/pages/GeneralSettings/ScheduledJobs/utils/cron.js
@@ -0,0 +1,158 @@
+import cronstrue from "cronstrue";
+
+// Render a 5-field cron expression as plain English using cronstrue.
+// Falls back to the raw expression if parsing fails.
+export function humanizeCron(cron) {
+  if (!cron) return "";
+  try {
+    return cronstrue.toString(cron, { throwExceptionOnParseError: false });
+  } catch {
+    return cron;
+  }
+}
+
+// Default state for the visual builder. Used when an incoming cron expression
+// cannot be reverse-parsed into one of the builder's supported shapes.
+export const DEFAULT_BUILDER_STATE = {
+  frequency: "day",
+  minuteInterval: 1,
+  hourMinuteOffset: 0,
+  hour: 9,
+  minute: 0,
+  weekdays: [1],
+  dayOfMonth: 1,
+};
+
+// Parse a 5-field cron expression into the visual builder's state shape.
+// Only recognizes the patterns the builder itself can produce; anything else
+// (ranges, step values in non-minute fields, multiple months, etc.) is
+// reported with `wasFallback: true` so the UI can warn the user that the
+// stored expression cannot be edited visually.
+//
+// Returns: { state, wasFallback }
+export function parseCronToBuilderState(cron) {
+  const fallback = { state: { ...DEFAULT_BUILDER_STATE }, wasFallback: true };
+  if (!cron || typeof cron !== "string") return fallback;
+  const parts = cron.trim().split(/\s+/);
+  if (parts.length !== 5) return fallback;
+  const [m, h, dom, mon, dow] = parts;
+  if (mon !== "*") return fallback;
+
+  // Every minute
+  if (m === "*" && h === "*" && dom === "*" && dow === "*") {
+    return {
+      state: {
+        ...DEFAULT_BUILDER_STATE,
+        frequency: "minute",
+        minuteInterval: 1,
+      },
+      wasFallback: false,
+    };
+  }
+
+  // Every N minutes
+  const stepMatch = m.match(/^\*\/(\d+)$/);
+  if (stepMatch && h === "*" && dom === "*" && dow === "*") {
+    return {
+      state: {
+        ...DEFAULT_BUILDER_STATE,
+        frequency: "minute",
+        minuteInterval: parseInt(stepMatch[1], 10),
+      },
+      wasFallback: false,
+    };
+  }
+
+  // Hourly at minute X
+  if (/^\d+$/.test(m) && h === "*" && dom === "*" && dow === "*") {
+    return {
+      state: {
+        ...DEFAULT_BUILDER_STATE,
+        frequency: "hour",
+        hourMinuteOffset: parseInt(m, 10),
+      },
+      wasFallback: false,
+    };
+  }
+
+  // Daily at H:M
+  if (/^\d+$/.test(m) && /^\d+$/.test(h) && dom === "*" && dow === "*") {
+    return {
+      state: {
+        ...DEFAULT_BUILDER_STATE,
+        frequency: "day",
+        hour: parseInt(h, 10),
+        minute: parseInt(m, 10),
+      },
+      wasFallback: false,
+    };
+  }
+
+  // Weekly on one or more weekdays at H:M
+  if (
+    /^\d+$/.test(m) &&
+    /^\d+$/.test(h) &&
+    dom === "*" &&
+    /^\d+(,\d+)*$/.test(dow)
+  ) {
+    const days = [
+      ...new Set(
+        dow
+          .split(",")
+          .map((d) => parseInt(d, 10) % 7)
+          .filter((d) => d >= 0 && d <= 6)
+      ),
+    ];
+    return {
+      state: {
+        ...DEFAULT_BUILDER_STATE,
+        frequency: "week",
+        hour: parseInt(h, 10),
+        minute: parseInt(m, 10),
+        weekdays: days.length ? days : [1],
+      },
+      wasFallback: false,
+    };
+  }
+
+  // Monthly on day D at H:M
+  if (/^\d+$/.test(m) && /^\d+$/.test(h) && /^\d+$/.test(dom) && dow === "*") {
+    return {
+      state: {
+        ...DEFAULT_BUILDER_STATE,
+        frequency: "month",
+        hour: parseInt(h, 10),
+        minute: parseInt(m, 10),
+        dayOfMonth: parseInt(dom, 10),
+      },
+      wasFallback: false,
+    };
+  }
+
+  return fallback;
+}
+
+// Build a 5-field cron expression from the visual builder's state.
+export function buildCronFromBuilderState(state) {
+  switch (state.frequency) {
+    case "minute": {
+      const n = state.minuteInterval || 1;
+      return n === 1 ? "* * * * *" : `*/${n} * * * *`;
+    }
+    case "hour":
+      return `${state.hourMinuteOffset} * * * *`;
+    case "day":
+      return `${state.minute} ${state.hour} * * *`;
+    case "week": {
+      const days = (state.weekdays?.length ? state.weekdays : [1])
+        .slice()
+        .sort((a, b) => a - b)
+        .join(",");
+      return `${state.minute} ${state.hour} * * ${days}`;
+    }
+    case "month":
+      return `${state.minute} ${state.hour} ${state.dayOfMonth} * *`;
+    default:
+      return "0 9 * * *";
+  }
+}
diff --git a/frontend/src/utils/paths.js b/frontend/src/utils/paths.js
index 78124e37439..447573b8387 100644
--- a/frontend/src/utils/paths.js
+++ b/frontend/src/utils/paths.js
@@ -173,6 +173,15 @@ export default {
     telegram: () => {
       return `/settings/external-connections/telegram`;
     },
+    scheduledJobs: () => {
+      return `/settings/scheduled-jobs`;
+    },
+    scheduledJobRuns: (jobId) => {
+      return `/settings/scheduled-jobs/${jobId}/runs`;
+    },
+    scheduledJobRunDetail: (jobId, runId) => {
+      return `/settings/scheduled-jobs/${jobId}/runs/${runId}`;
+    },
   },
   agents: {
     builder: () => {
diff --git a/frontend/yarn.lock b/frontend/yarn.lock
index b932057bac4..d6738b43f04 100644
--- a/frontend/yarn.lock
+++ b/frontend/yarn.lock
@@ -1711,6 +1711,11 @@ cosmiconfig@^7.0.0:
     path-type "^4.0.0"
     yaml "^1.10.0"
 
+cronstrue@^2.50.0:
+  version "2.61.0"
+  resolved "https://registry.yarnpkg.com/cronstrue/-/cronstrue-2.61.0.tgz#97c79c77045c052afb44cb9f5f8eaf54398094f2"
+  integrity sha512-ootN5bvXbIQI9rW94+QsXN5eROtXWwew6NkdGxIRpS/UFWRggL0G5Al7a9GTBFEsuvVhJ2K3CntIIVt7L2ILhA==
+
 cross-env@^7.0.3:
   version "7.0.3"
   resolved "https://registry.yarnpkg.com/cross-env/-/cross-env-7.0.3.tgz#865264b29677dc015ba8418918965dd232fc54cf"
diff --git a/server/.env.example b/server/.env.example
index 3d08207cdcc..5ca86e29534 100644
--- a/server/.env.example
+++ b/server/.env.example
@@ -454,3 +454,11 @@ TTS_PROVIDER="native"
 # many tools/MCP servers enabled.
 # AGENT_SKILL_RERANKER_ENABLED="true"
 # AGENT_SKILL_RERANKER_TOP_N=15 # (optional) Number of top tools to keep after reranking (default: 15)
+
+# (optional) Maximum number of scheduled jobs that can run concurrently.
+# Default is 1. Increase if using a cloud LLM provider with high rate limits.
+# SCHEDULED_JOB_MAX_CONCURRENT=1
+
+# (optional) Maximum time in milliseconds a scheduled job can run before being terminated.
+# Default is 5 minutes (300000ms).
+# SCHEDULED_JOB_TIMEOUT_MS=300000
diff --git a/server/endpoints/agentFileServer.js b/server/endpoints/agentFileServer.js
index daaf5002a82..fc8f2f2f487 100644
--- a/server/endpoints/agentFileServer.js
+++ b/server/endpoints/agentFileServer.js
@@ -10,6 +10,7 @@ const {
 } = require("../utils/middleware/multiUserProtected");
 const { WorkspaceChats } = require("../models/workspaceChats");
 const { Workspace } = require("../models/workspace");
+const { ScheduledJobRun } = require("../models/scheduledJobRun");
 const createFilesLib = require("../utils/agents/aibitat/plugins/create-files/lib");
 
 /**
@@ -42,12 +43,13 @@ function agentFileServerEndpoints(app) {
             .json({ error: "Invalid filename format" });
         }
 
-        // Find a chat record that references this file and that the user can access
-        const validChat = await findValidChatForFile(
-          filename,
-          user,
-          multiUserMode(response)
-        );
+        // Find a chat or scheduled job run that references this file
+        const validChat =
+          (await findValidChatForFile(
+            filename,
+            user,
+            multiUserMode(response)
+          )) || (await findValidScheduledJobRunForFile(filename));
 
         if (!validChat) {
           return response.status(404).json({
@@ -139,4 +141,40 @@ async function findValidChatForFile(storageFilename, user, isMultiUser) {
   }
 }
 
+/**
+ * Finds a scheduled job run that references the given storage filename.
+ * Scheduled jobs are single-user only, so no per-user access check is needed.
+ * @param {string} storageFilename
+ * @returns {Promise<{workspaceId: number, displayFilename: string}|null>}
+ */
+async function findValidScheduledJobRunForFile(storageFilename) {
+  try {
+    const runs = await ScheduledJobRun.where({
+      status: "completed",
+      result: { contains: storageFilename },
+    });
+
+    for (const run of runs) {
+      try {
+        const result = safeJsonParse(run.result, { generatedFiles: [] });
+        const file = result.generatedFiles?.find(
+          (f) => f?.storageFilename === storageFilename
+        );
+        if (!file) continue;
+        return {
+          workspaceId: null,
+          displayFilename: file.filename || storageFilename,
+        };
+      } catch {
+        continue;
+      }
+    }
+
+    return null;
+  } catch (error) {
+    console.error("[findValidScheduledJobRunForFile] Error:", error.message);
+    return null;
+  }
+}
+
 module.exports = { agentFileServerEndpoints };
diff --git a/server/endpoints/scheduledJobs.js b/server/endpoints/scheduledJobs.js
new file mode 100644
index 00000000000..f39c211b52a
--- /dev/null
+++ b/server/endpoints/scheduledJobs.js
@@ -0,0 +1,464 @@
+const { ScheduledJob } = require("../models/scheduledJob");
+const { ScheduledJobRun } = require("../models/scheduledJobRun");
+const { Workspace } = require("../models/workspace");
+const { WorkspaceThread } = require("../models/workspaceThread");
+const { WorkspaceChats } = require("../models/workspaceChats");
+const { validatedRequest } = require("../utils/middleware/validatedRequest");
+const { isSingleUserMode } = require("../utils/middleware/multiUserProtected");
+const { reqBody, safeJsonParse } = require("../utils/http");
+const { agentSkillsFromSystemSettings } = require("../utils/agents/defaults");
+const ImportedPlugin = require("../utils/agents/imported");
+const { AgentFlows } = require("../utils/agentFlows");
+const MCPCompatibilityLayer = require("../utils/MCP");
+
+function scheduledJobEndpoints(app) {
+  if (!app) return;
+
+  // List available tools for job configuration
+  app.get(
+    "/scheduled-jobs/available-tools",
+    [validatedRequest, isSingleUserMode],
+    async (_request, response) => {
+      try {
+        // Built-in skills — already human-readable identifiers
+        const builtIn = (await agentSkillsFromSystemSettings()).map((id) => ({
+          id,
+          name: id,
+        }));
+
+        // Imported plugins — resolve hubId to name from plugin.json
+        const imported = ImportedPlugin.activeImportedPlugins().map((id) => {
+          const hubId = id.replace("@@", "");
+          let name = hubId;
+          try {
+            const plugin = ImportedPlugin.loadPluginByHubId(hubId);
+            if (plugin?.name) name = plugin.name;
+          } catch {}
+          return { id, name };
+        });
+
+        // Agent flows — resolve UUID to flow name
+        const flows = AgentFlows.activeFlowPlugins().map((id) => {
+          const uuid = id.replace("@@flow_", "");
+          let name = uuid;
+          try {
+            const allFlows = AgentFlows.getAllFlows();
+            if (allFlows[uuid]?.name) name = allFlows[uuid].name;
+          } catch {}
+          return { id, name: `Flow: ${name}` };
+        });
+
+        // MCP servers — strip prefix for display
+        const mcp = (await new MCPCompatibilityLayer().activeMCPServers()).map(
+          (id) => ({
+            id,
+            name: `MCP: ${id.replace("@@mcp_", "")}`,
+          })
+        );
+
+        return response
+          .status(200)
+          .json({ tools: [...builtIn, ...imported, ...flows, ...mcp] });
+      } catch (e) {
+        console.error(e.message, e);
+        response.sendStatus(500);
+      }
+    }
+  );
+
+  // Get a single run detail
+  app.get(
+    "/scheduled-jobs/runs/:runId",
+    [validatedRequest, isSingleUserMode],
+    async (request, response) => {
+      try {
+        const run = await ScheduledJobRun.get({
+          id: Number(request.params.runId),
+        });
+        if (!run) {
+          return response
+            .status(404)
+            .json({ run: null, error: "Run not found" });
+        }
+
+        const job = await ScheduledJob.get({ id: run.jobId });
+        return response.status(200).json({
+          run: {
+            ...run,
+            result: safeJsonParse(run.result, null),
+          },
+          job,
+        });
+      } catch (e) {
+        console.error(e.message, e);
+        response.sendStatus(500);
+      }
+    }
+  );
+
+  // Mark a run as read
+  app.post(
+    "/scheduled-jobs/runs/:runId/read",
+    [validatedRequest, isSingleUserMode],
+    async (request, response) => {
+      try {
+        await ScheduledJobRun.markRead(Number(request.params.runId));
+        return response.status(200).json({ success: true });
+      } catch (e) {
+        console.error(e.message, e);
+        response.sendStatus(500);
+      }
+    }
+  );
+
+  // Continue a run in a workspace thread
+  app.post(
+    "/scheduled-jobs/runs/:runId/continue",
+    [validatedRequest, isSingleUserMode],
+    async (request, response) => {
+      try {
+        const run = await ScheduledJobRun.get({
+          id: Number(request.params.runId),
+        });
+        if (!run) {
+          return response.status(404).json({ error: "Run not found" });
+        }
+
+        const job = await ScheduledJob.get({ id: run.jobId });
+        if (!job) {
+          return response.status(404).json({ error: "Job not found" });
+        }
+
+        const result = safeJsonParse(run.result, {});
+        const responseText = result?.text || "No response was generated.";
+
+        // Get or create the "Scheduled Jobs" workspace
+        let workspace = await Workspace.get({ slug: "scheduled-jobs" });
+        if (!workspace) {
+          const wsResult = await Workspace.new("Scheduled Jobs");
+          workspace = wsResult.workspace;
+          if (!workspace) {
+            return response
+              .status(500)
+              .json({ error: "Failed to create workspace" });
+          }
+        }
+
+        const threadName = `${job.name} - ${new Date(run.startedAt).toLocaleString()}`;
+        const { thread, message: threadError } = await WorkspaceThread.new(
+          workspace,
+          null,
+          { name: threadName }
+        );
+
+        if (!thread) {
+          return response
+            .status(500)
+            .json({ error: threadError || "Failed to create thread" });
+        }
+
+        await WorkspaceChats.new({
+          workspaceId: workspace.id,
+          prompt: job.prompt,
+          response: {
+            text: responseText,
+            sources: result.sources || [],
+            type: "chat",
+          },
+          threadId: thread.id,
+          include: true,
+        });
+
+        return response.status(200).json({
+          workspaceSlug: workspace.slug,
+          threadSlug: thread.slug,
+        });
+      } catch (e) {
+        console.error(e.message, e);
+        response.sendStatus(500);
+      }
+    }
+  );
+
+  // List all scheduled jobs
+  app.get(
+    "/scheduled-jobs",
+    [validatedRequest, isSingleUserMode],
+    async (_request, response) => {
+      try {
+        const jobs = await ScheduledJob.where();
+
+        const jobsWithStatus = await Promise.all(
+          jobs.map(async (job) => {
+            const [latestRun] = await ScheduledJobRun.where(
+              { jobId: job.id },
+              1,
+              { startedAt: "desc" }
+            );
+            return {
+              ...job,
+              latestRun: latestRun || null,
+            };
+          })
+        );
+
+        return response.status(200).json({ jobs: jobsWithStatus });
+      } catch (e) {
+        console.error(e.message, e);
+        response.sendStatus(500);
+      }
+    }
+  );
+
+  // Create a new scheduled job
+  app.post(
+    "/scheduled-jobs/new",
+    [validatedRequest, isSingleUserMode],
+    async (request, response) => {
+      try {
+        const { name, prompt, tools, schedule } = reqBody(request);
+
+        if (!name || !name.trim()) {
+          return response
+            .status(400)
+            .json({ job: null, error: "Name is required" });
+        }
+        if (!prompt || !prompt.trim()) {
+          return response
+            .status(400)
+            .json({ job: null, error: "Prompt is required" });
+        }
+        if (!schedule || !schedule.trim()) {
+          return response
+            .status(400)
+            .json({ job: null, error: "Schedule is required" });
+        }
+        if (!ScheduledJob.isValidCron(schedule)) {
+          return response
+            .status(400)
+            .json({ job: null, error: "Invalid cron expression" });
+        }
+        if (tools && !Array.isArray(tools)) {
+          return response
+            .status(400)
+            .json({ job: null, error: "Tools must be an array" });
+        }
+
+        // New jobs default to enabled, so creating one always counts as an
+        // activation. Reject if it would push us past the configured cap.
+        const activation = await ScheduledJob.canActivate();
+        if (!activation.allowed) {
+          return response.status(400).json({
+            job: null,
+            error: `Cannot create: maximum of ${activation.limit} active scheduled jobs reached. Disable another job first.`,
+          });
+        }
+
+        const { job, error } = await ScheduledJob.create({
+          name: name.trim(),
+          prompt: prompt.trim(),
+          tools: tools || null,
+          schedule: schedule.trim(),
+        });
+
+        if (error) {
+          return response.status(400).json({ job: null, error });
+        }
+
+        const { BackgroundService } = require("../utils/BackgroundWorkers");
+        new BackgroundService().addScheduledJob(job);
+
+        return response.status(201).json({ job, error: null });
+      } catch (e) {
+        console.error(e.message, e);
+        response.sendStatus(500);
+      }
+    }
+  );
+
+  // Get a single scheduled job
+  app.get(
+    "/scheduled-jobs/:id",
+    [validatedRequest, isSingleUserMode],
+    async (request, response) => {
+      try {
+        const job = await ScheduledJob.get({
+          id: Number(request.params.id),
+        });
+        if (!job) {
+          return response
+            .status(404)
+            .json({ job: null, error: "Job not found" });
+        }
+        return response.status(200).json({ job });
+      } catch (e) {
+        console.error(e.message, e);
+        response.sendStatus(500);
+      }
+    }
+  );
+
+  // Update a scheduled job
+  app.put(
+    "/scheduled-jobs/:id",
+    [validatedRequest, isSingleUserMode],
+    async (request, response) => {
+      try {
+        const { name, prompt, tools, schedule, enabled } = reqBody(request);
+        const updates = {};
+
+        if (name !== undefined) updates.name = String(name).trim();
+        if (prompt !== undefined) updates.prompt = String(prompt).trim();
+        if (tools !== undefined) updates.tools = tools;
+        if (enabled !== undefined) updates.enabled = Boolean(enabled);
+        if (schedule !== undefined) {
+          if (!ScheduledJob.isValidCron(schedule)) {
+            return response
+              .status(400)
+              .json({ job: null, error: "Invalid cron expression" });
+          }
+          updates.schedule = String(schedule).trim();
+        }
+
+        // If this update would activate the job, enforce the active-jobs cap.
+        // We pass excludeId so a re-save of an already-enabled job is not
+        // double-counted against the limit.
+        if (updates.enabled === true) {
+          const activation = await ScheduledJob.canActivate({
+            excludeId: Number(request.params.id),
+          });
+          if (!activation.allowed) {
+            return response.status(400).json({
+              job: null,
+              error: `Cannot enable: maximum of ${activation.limit} active scheduled jobs reached. Disable another job first.`,
+            });
+          }
+        }
+
+        const { job, error } = await ScheduledJob.update(
+          Number(request.params.id),
+          updates
+        );
+
+        if (error) {
+          return response.status(400).json({ job: null, error });
+        }
+
+        const { BackgroundService } = require("../utils/BackgroundWorkers");
+        await new BackgroundService().syncScheduledJob(job.id);
+
+        return response.status(200).json({ job, error: null });
+      } catch (e) {
+        console.error(e.message, e);
+        response.sendStatus(500);
+      }
+    }
+  );
+
+  // Delete a scheduled job
+  app.delete(
+    "/scheduled-jobs/:id",
+    [validatedRequest, isSingleUserMode],
+    async (request, response) => {
+      try {
+        const { BackgroundService } = require("../utils/BackgroundWorkers");
+        new BackgroundService().removeScheduledJob(Number(request.params.id));
+
+        const success = await ScheduledJob.delete(Number(request.params.id));
+        return response.status(200).json({ success });
+      } catch (e) {
+        console.error(e.message, e);
+        response.sendStatus(500);
+      }
+    }
+  );
+
+  // Toggle enable/disable
+  app.post(
+    "/scheduled-jobs/:id/toggle",
+    [validatedRequest, isSingleUserMode],
+    async (request, response) => {
+      try {
+        const job = await ScheduledJob.get({
+          id: Number(request.params.id),
+        });
+        if (!job) {
+          return response.status(404).json({ error: "Job not found" });
+        }
+
+        // Toggling a disabled job to enabled is an activation — enforce the cap.
+        // Disabling never needs a check.
+        if (!job.enabled) {
+          const activation = await ScheduledJob.canActivate({
+            excludeId: job.id,
+          });
+          if (!activation.allowed) {
+            return response.status(400).json({
+              job: null,
+              error: `Cannot enable: maximum of ${activation.limit} active scheduled jobs reached. Disable another job first.`,
+            });
+          }
+        }
+
+        const { job: updated } = await ScheduledJob.update(job.id, {
+          enabled: !job.enabled,
+        });
+
+        const { BackgroundService } = require("../utils/BackgroundWorkers");
+        await new BackgroundService().syncScheduledJob(job.id);
+
+        return response.status(200).json({ job: updated });
+      } catch (e) {
+        console.error(e.message, e);
+        response.sendStatus(500);
+      }
+    }
+  );
+
+  // Manual trigger — runs the job immediately
+  app.post(
+    "/scheduled-jobs/:id/trigger",
+    [validatedRequest, isSingleUserMode],
+    async (request, response) => {
+      try {
+        const job = await ScheduledJob.get({
+          id: Number(request.params.id),
+        });
+        if (!job) {
+          return response.status(404).json({ error: "Job not found" });
+        }
+
+        const { BackgroundService } = require("../utils/BackgroundWorkers");
+        new BackgroundService().enqueueScheduledJob(job.id, {
+          priority: true,
+        });
+
+        return response.status(200).json({ success: true, error: null });
+      } catch (e) {
+        console.error(e.message, e);
+        response.sendStatus(500);
+      }
+    }
+  );
+
+  // List runs for a job
+  app.get(
+    "/scheduled-jobs/:id/runs",
+    [validatedRequest, isSingleUserMode],
+    async (request, response) => {
+      try {
+        const runs = await ScheduledJobRun.where(
+          { jobId: Number(request.params.id) },
+          50,
+          { startedAt: "desc" }
+        );
+        return response.status(200).json({ runs });
+      } catch (e) {
+        console.error(e.message, e);
+        response.sendStatus(500);
+      }
+    }
+  );
+}
+
+module.exports = { scheduledJobEndpoints };
diff --git a/server/index.js b/server/index.js
index 5d6b94da6b9..0568c2173fd 100644
--- a/server/index.js
+++ b/server/index.js
@@ -35,6 +35,7 @@ const { mcpServersEndpoints } = require("./endpoints/mcpServers");
 const { mobileEndpoints } = require("./endpoints/mobile");
 const { webPushEndpoints } = require("./endpoints/webPush");
 const { telegramEndpoints } = require("./endpoints/telegram");
+const { scheduledJobEndpoints } = require("./endpoints/scheduledJobs");
 const { httpLogger } = require("./middleware/httpLogger");
 const app = express();
 const apiRouter = express.Router();
@@ -89,6 +90,7 @@ mcpServersEndpoints(apiRouter);
 mobileEndpoints(apiRouter);
 webPushEndpoints(apiRouter);
 telegramEndpoints(apiRouter);
+scheduledJobEndpoints(apiRouter);
 // Externally facing embedder endpoints
 embeddedEndpoints(apiRouter);
 
diff --git a/server/jobs/run-scheduled-job.js b/server/jobs/run-scheduled-job.js
new file mode 100644
index 00000000000..67dbba9dcdf
--- /dev/null
+++ b/server/jobs/run-scheduled-job.js
@@ -0,0 +1,217 @@
+const { log, conclude } = require("./helpers/index.js");
+const { v4: uuidv4 } = require("uuid");
+const { safeJsonParse } = require("../utils/http");
+
+process.on("message", async (payload) => {
+  const { jobId } = payload;
+  if (!jobId) {
+    conclude();
+    return;
+  }
+
+  const { ScheduledJob } = require("../models/scheduledJob.js");
+  const { ScheduledJobRun } = require("../models/scheduledJobRun.js");
+
+  let run = null;
+
+  try {
+    const job = await ScheduledJob.get({ id: Number(jobId) });
+    if (!job) {
+      log(`Scheduled job ${jobId} not found`);
+      conclude();
+      return;
+    }
+
+    log(`Starting scheduled job: "${job.name}" (id=${job.id})`);
+
+    // Create run record
+    run = await ScheduledJobRun.create(job.id);
+    if (!run) {
+      log(`Failed to create run record for job ${job.id}`);
+      conclude();
+      return;
+    }
+
+    // Update timestamps now so nextRunAt advances even if the job fails
+    await ScheduledJob.updateRunTimestamps(job.id);
+
+    // Get or create the dedicated "Scheduled Jobs" workspace
+    const { Workspace } = require("../models/workspace.js");
+    let workspace = await Workspace.get({ slug: "scheduled-jobs" });
+    if (!workspace) {
+      const result = await Workspace.new("Scheduled Jobs");
+      workspace = result.workspace;
+      if (!workspace) {
+        throw new Error("Failed to create Scheduled Jobs workspace");
+      }
+      log("Created dedicated 'Scheduled Jobs' workspace");
+    }
+
+    // Build trace-capturing handler
+    const thoughts = [];
+    const toolCalls = [];
+    const generatedFiles = [];
+    let textResponse = "";
+    let metrics = {};
+    let handlerResolve = null;
+
+    const handlerPromise = new Promise((resolve) => {
+      handlerResolve = resolve;
+    });
+
+    const handler = {
+      send(jsonStr) {
+        const data = safeJsonParse(jsonStr, null);
+        if (!data) return;
+
+        if (data.type === "fileDownloadCard" && data.content) {
+          generatedFiles.push(data.content);
+          return;
+        }
+
+        if (data.type === "statusResponse" && data.content) {
+          thoughts.push(data.content);
+          return;
+        }
+
+        if (data.type === "reportStreamEvent" && data.content) {
+          const inner = data.content;
+          if (inner.type === "textResponseChunk" && inner.content) {
+            textResponse += inner.content;
+          }
+          if (inner.type === "fullTextResponse" && inner.content) {
+            textResponse = inner.content;
+          }
+          if (inner.type === "usageMetrics" && inner.metrics) {
+            metrics = inner.metrics;
+          }
+          return;
+        }
+
+        // Final message from agent (onMessage event)
+        if (data.content && data.from && data.from !== "USER") {
+          if (!textResponse) textResponse = data.content;
+        }
+      },
+      close() {
+        if (handlerResolve) handlerResolve();
+      },
+    };
+
+    // Create agent handler
+    const { EphemeralAgentHandler } = require("../utils/agents/ephemeral.js");
+
+    const agentHandler = await new EphemeralAgentHandler({
+      uuid: uuidv4(),
+      workspace,
+      prompt: job.prompt,
+      userId: null,
+      threadId: null,
+    }).init();
+
+    // Tool overrides control which tools the agent can use:
+    // - Array with items: only those specific tools are loaded
+    // - Empty array: no tools are loaded
+    // - null: all enabled agent skills are loaded (default behavior)
+    const toolOverrides = safeJsonParse(job.tools, null);
+
+    await agentHandler.createAIbitat({
+      handler,
+      toolOverrides,
+    });
+
+    // Auto-approve all tool invocations
+    agentHandler.aibitat.requestToolApproval = async () => ({
+      approved: true,
+      message: "Auto-approved by scheduled job runner.",
+    });
+
+    // Capture tool results for the execution trace
+    agentHandler.aibitat.onToolCallResult(
+      ({ toolName, arguments: args, result }) => {
+        toolCalls.push({
+          toolName,
+          arguments: args,
+          result,
+          timestamp: Date.now(),
+        });
+      }
+    );
+
+    // Execute with timeout
+    const TIMEOUT =
+      Number(process.env.SCHEDULED_JOB_TIMEOUT_MS) || 5 * 60 * 1000;
+    const startTime = Date.now();
+
+    await Promise.race([
+      agentHandler.startAgentCluster(),
+      new Promise((_, reject) =>
+        setTimeout(() => reject(new Error("SCHEDULED_JOB_TIMEOUT")), TIMEOUT)
+      ),
+    ]);
+
+    // Wait for handler close (agent termination)
+    await Promise.race([
+      handlerPromise,
+      new Promise((resolve) => setTimeout(resolve, 5000)),
+    ]);
+
+    const duration = Date.now() - startTime;
+
+    // Save completed result
+    await ScheduledJobRun.complete(run.id, {
+      result: {
+        text: textResponse,
+        thoughts,
+        toolCalls,
+        generatedFiles,
+        metrics,
+        duration,
+      },
+    });
+
+    log(
+      `Job "${job.name}" completed in ${duration}ms (${textResponse.length} chars)`
+    );
+
+    // Send push notification — must load subscriptions since this is a child process
+    try {
+      const {
+        pushNotificationService,
+      } = require("../utils/PushNotifications/index.js");
+      await pushNotificationService.loadSubscriptions();
+      await pushNotificationService.sendNotification({
+        to: "primary",
+        payload: {
+          title: `Scheduled Job: ${job.name}`,
+          body: textResponse
+            ? textResponse.slice(0, 100) +
+              (textResponse.length > 100 ? "..." : "")
+            : "Job completed",
+          data: {
+            onClickUrl: `/settings/scheduled-jobs/${job.id}/runs/${run.id}`,
+          },
+        },
+      });
+    } catch (pushError) {
+      log(`Failed to send push notification: ${pushError.message}`);
+    }
+  } catch (error) {
+    const isTimeout = error.message === "SCHEDULED_JOB_TIMEOUT";
+    log(
+      isTimeout
+        ? `Scheduled job timed out`
+        : `Scheduled job error: ${error.message}`
+    );
+
+    if (run) {
+      if (isTimeout) {
+        await ScheduledJobRun.timeout(run.id);
+      } else {
+        await ScheduledJobRun.fail(run.id, { error: error.message });
+      }
+    }
+  } finally {
+    conclude();
+  }
+});
diff --git a/server/models/scheduledJob.js b/server/models/scheduledJob.js
new file mode 100644
index 00000000000..368367cbdb0
--- /dev/null
+++ b/server/models/scheduledJob.js
@@ -0,0 +1,226 @@
+const prisma = require("../utils/prisma");
+
+const ScheduledJob = {
+  writable: ["name", "prompt", "tools", "schedule", "enabled"],
+
+  // Maximum number of scheduled jobs that can be enabled at once.
+  // null = no limit. Set to a positive integer to cap concurrent active jobs;
+  // attempting to enable a job past the cap will be rejected at the API layer.
+  MAX_ACTIVE: null,
+
+  /**
+   * Compute the next run time from a cron expression.
+   * Uses @breejs/later which is already available via Bree.
+   * @param {string} cronExpression
+   * @returns {Date|null}
+   */
+  computeNextRunAt: function (cronExpression) {
+    try {
+      const later = require("@breejs/later");
+      const sched = later.parse.cron(cronExpression);
+      const next = later.schedule(sched).next(1);
+      return next || null;
+    } catch (error) {
+      console.error(
+        "Failed to compute next run time from cron:",
+        error.message
+      );
+      return null;
+    }
+  },
+
+  /**
+   * Validate a cron expression.
+   * Uses cron-validate which is already available via Bree.
+   * @param {string} cronExpression
+   * @returns {boolean}
+   */
+  isValidCron: function (cronExpression) {
+    try {
+      const cron = require("cron-validate").default;
+      return cron(cronExpression).isValid();
+    } catch {
+      return false;
+    }
+  },
+
+  create: async function ({ name, prompt, tools = null, schedule } = {}) {
+    try {
+      const nextRunAt = this.computeNextRunAt(schedule);
+      const job = await prisma.scheduled_jobs.create({
+        data: {
+          name: String(name),
+          prompt: String(prompt),
+          tools: tools ? JSON.stringify(tools) : null,
+          schedule: String(schedule),
+          nextRunAt,
+        },
+      });
+      return { job, error: null };
+    } catch (error) {
+      console.error("Failed to create scheduled job:", error.message);
+      return { job: null, error: error.message };
+    }
+  },
+
+  update: async function (id, data = {}) {
+    try {
+      const updates = {};
+      for (const key of this.writable) {
+        if (data.hasOwnProperty(key)) {
+          if (key === "tools") {
+            updates[key] = data[key] ? JSON.stringify(data[key]) : null;
+          } else {
+            updates[key] = data[key];
+          }
+        }
+      }
+
+      // Recompute nextRunAt if schedule changed
+      if (updates.schedule) {
+        updates.nextRunAt = this.computeNextRunAt(updates.schedule);
+      }
+
+      updates.updatedAt = new Date();
+
+      const job = await prisma.scheduled_jobs.update({
+        where: { id: Number(id) },
+        data: updates,
+      });
+      return { job, error: null };
+    } catch (error) {
+      console.error("Failed to update scheduled job:", error.message);
+      return { job: null, error: error.message };
+    }
+  },
+
+  get: async function (clause = {}) {
+    try {
+      const job = await prisma.scheduled_jobs.findFirst({ where: clause });
+      return job || null;
+    } catch (error) {
+      console.error("Failed to get scheduled job:", error.message);
+      return null;
+    }
+  },
+
+  where: async function (clause = {}, limit = null, orderBy = null) {
+    try {
+      const results = await prisma.scheduled_jobs.findMany({
+        where: clause,
+        ...(limit !== null ? { take: limit } : {}),
+        ...(orderBy !== null
+          ? { orderBy }
+          : { orderBy: { createdAt: "desc" } }),
+      });
+      return results;
+    } catch (error) {
+      console.error("Failed to query scheduled jobs:", error.message);
+      return [];
+    }
+  },
+
+  delete: async function (id) {
+    try {
+      await prisma.scheduled_jobs.delete({ where: { id: Number(id) } });
+      return true;
+    } catch (error) {
+      console.error("Failed to delete scheduled job:", error.message);
+      return false;
+    }
+  },
+
+  allEnabled: async function () {
+    try {
+      return await prisma.scheduled_jobs.findMany({
+        where: { enabled: true },
+      });
+    } catch (error) {
+      console.error("Failed to get enabled scheduled jobs:", error.message);
+      return [];
+    }
+  },
+
+  /**
+   * Count enabled scheduled jobs, optionally excluding a single job by id.
+   * `excludeId` is used by canActivate so that re-saving an already-enabled job
+   * is not double-counted against the limit.
+   * @param {number|null} excludeId
+   * @returns {Promise<number>}
+   */
+  countActive: async function (excludeId = null) {
+    try {
+      return await prisma.scheduled_jobs.count({
+        where: {
+          enabled: true,
+          ...(excludeId != null ? { NOT: { id: Number(excludeId) } } : {}),
+        },
+      });
+    } catch (error) {
+      console.error("Failed to count active scheduled jobs:", error.message);
+      return 0;
+    }
+  },
+
+  /**
+   * Check whether a job can be activated without exceeding MAX_ACTIVE.
+   * Pass `excludeId` when re-saving an existing job to avoid counting it twice.
+   * @param {{ excludeId?: number|null }} [opts]
+   * @returns {Promise<{ allowed: boolean, limit: number|null, current: number }>}
+   */
+  canActivate: async function ({ excludeId = null } = {}) {
+    const limit = this.MAX_ACTIVE;
+    if (limit == null) {
+      return { allowed: true, limit: null, current: 0 };
+    }
+    const current = await this.countActive(excludeId);
+    return { allowed: current < limit, limit, current };
+  },
+
+  /**
+   * Recompute nextRunAt from the current time.
+   * Used on cold startup to correct stale nextRunAt values.
+   * @param {number} id
+   */
+  recomputeNextRunAt: async function (id) {
+    try {
+      const job = await this.get({ id: Number(id) });
+      if (!job) return;
+
+      const nextRunAt = this.computeNextRunAt(job.schedule);
+      if (!nextRunAt) return;
+
+      await prisma.scheduled_jobs.update({
+        where: { id: Number(id) },
+        data: { nextRunAt, updatedAt: new Date() },
+      });
+    } catch (error) {
+      console.error("Failed to recompute nextRunAt:", error.message);
+    }
+  },
+
+  /**
+   * Update lastRunAt and nextRunAt after a job run.
+   * @param {number} id
+   */
+  updateRunTimestamps: async function (id) {
+    try {
+      const job = await this.get({ id: Number(id) });
+      if (!job) return;
+
+      const nextRunAt = this.computeNextRunAt(job.schedule);
+      await prisma.scheduled_jobs.update({
+        where: { id: Number(id) },
+        data: {
+          lastRunAt: new Date(),
+          nextRunAt,
+          updatedAt: new Date(),
+        },
+      });
+    } catch (error) {
+      console.error("Failed to update run timestamps:", error.message);
+    }
+  },
+};
+
+module.exports = { ScheduledJob };
diff --git a/server/models/scheduledJobRun.js b/server/models/scheduledJobRun.js
new file mode 100644
index 00000000000..87a35aea2a7
--- /dev/null
+++ b/server/models/scheduledJobRun.js
@@ -0,0 +1,161 @@
+const prisma = require("../utils/prisma");
+
+const ScheduledJobRun = {
+  statuses: {
+    running: "running",
+    completed: "completed",
+    failed: "failed",
+    timed_out: "timed_out",
+  },
+
+  create: async function (jobId) {
+    try {
+      const run = await prisma.scheduled_job_runs.create({
+        data: {
+          jobId: Number(jobId),
+          status: this.statuses.running,
+        },
+      });
+      return run || null;
+    } catch (error) {
+      console.error("Failed to create scheduled job run:", error.message);
+      return null;
+    }
+  },
+
+  complete: async function (id, { result } = {}) {
+    try {
+      const run = await prisma.scheduled_job_runs.update({
+        where: { id: Number(id) },
+        data: {
+          status: this.statuses.completed,
+          result: typeof result === "string" ? result : JSON.stringify(result),
+          completedAt: new Date(),
+        },
+      });
+      return run;
+    } catch (error) {
+      console.error("Failed to complete scheduled job run:", error.message);
+      return null;
+    }
+  },
+
+  fail: async function (id, { error: errorMsg } = {}) {
+    try {
+      const run = await prisma.scheduled_job_runs.update({
+        where: { id: Number(id) },
+        data: {
+          status: this.statuses.failed,
+          error: String(errorMsg || "Unknown error"),
+          completedAt: new Date(),
+        },
+      });
+      return run;
+    } catch (error) {
+      console.error(
+        "Failed to mark scheduled job run as failed:",
+        error.message
+      );
+      return null;
+    }
+  },
+
+  timeout: async function (id) {
+    try {
+      const run = await prisma.scheduled_job_runs.update({
+        where: { id: Number(id) },
+        data: {
+          status: this.statuses.timed_out,
+          error: "Job execution timed out",
+          completedAt: new Date(),
+        },
+      });
+      return run;
+    } catch (error) {
+      console.error(
+        "Failed to mark scheduled job run as timed out:",
+        error.message
+      );
+      return null;
+    }
+  },
+
+  get: async function (clause = {}) {
+    try {
+      const run = await prisma.scheduled_job_runs.findFirst({
+        where: clause,
+      });
+      return run || null;
+    } catch (error) {
+      console.error("Failed to get scheduled job run:", error.message);
+      return null;
+    }
+  },
+
+  where: async function (
+    clause = {},
+    limit = null,
+    orderBy = null,
+    include = {}
+  ) {
+    try {
+      const results = await prisma.scheduled_job_runs.findMany({
+        where: clause,
+        ...(limit !== null ? { take: limit } : {}),
+        ...(orderBy !== null
+          ? { orderBy }
+          : { orderBy: { startedAt: "desc" } }),
+        ...(Object.keys(include).length > 0 ? { include } : {}),
+      });
+      return results;
+    } catch (error) {
+      console.error("Failed to query scheduled job runs:", error.message);
+      return [];
+    }
+  },
+
+  markRead: async function (id) {
+    try {
+      await prisma.scheduled_job_runs.update({
+        where: { id: Number(id) },
+        data: { readAt: new Date() },
+      });
+      return true;
+    } catch (error) {
+      console.error("Failed to mark run as read:", error.message);
+      return false;
+    }
+  },
+
+  delete: async function (clause = {}) {
+    try {
+      await prisma.scheduled_job_runs.deleteMany({ where: clause });
+      return true;
+    } catch (error) {
+      console.error("Failed to delete scheduled job runs:", error.message);
+      return false;
+    }
+  },
+
+  /**
+   * Mark all orphaned running runs as failed (for cold startup recovery).
+   */
+  failOrphanedRuns: async function () {
+    try {
+      const result = await prisma.scheduled_job_runs.updateMany({
+        where: { status: this.statuses.running },
+        data: {
+          status: this.statuses.failed,
+          error: "Server restarted during execution",
+          completedAt: new Date(),
+        },
+      });
+      return result.count;
+    } catch (error) {
+      console.error("Failed to fail orphaned runs:", error.message);
+      return 0;
+    }
+  },
+};
+
+module.exports = { ScheduledJobRun };
diff --git a/server/prisma/migrations/20260331000000_add_scheduled_jobs/migration.sql b/server/prisma/migrations/20260331000000_add_scheduled_jobs/migration.sql
new file mode 100644
index 00000000000..91073a39643
--- /dev/null
+++ b/server/prisma/migrations/20260331000000_add_scheduled_jobs/migration.sql
@@ -0,0 +1,29 @@
+-- CreateTable
+CREATE TABLE "scheduled_jobs" (
+    "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+    "name" TEXT NOT NULL,
+    "prompt" TEXT NOT NULL,
+    "tools" TEXT,
+    "schedule" TEXT NOT NULL,
+    "enabled" BOOLEAN NOT NULL DEFAULT true,
+    "lastRunAt" DATETIME,
+    "nextRunAt" DATETIME,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+-- CreateTable
+CREATE TABLE "scheduled_job_runs" (
+    "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+    "jobId" INTEGER NOT NULL,
+    "status" TEXT NOT NULL DEFAULT 'running',
+    "result" TEXT,
+    "error" TEXT,
+    "startedAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "completedAt" DATETIME,
+    "readAt" DATETIME,
+    CONSTRAINT "scheduled_job_runs_jobId_fkey" FOREIGN KEY ("jobId") REFERENCES "scheduled_jobs" ("id") ON DELETE CASCADE ON UPDATE CASCADE
+);
+
+-- CreateIndex
+CREATE INDEX "scheduled_job_runs_jobId_idx" ON "scheduled_job_runs"("jobId");
diff --git a/server/prisma/schema.prisma b/server/prisma/schema.prisma
index 326e5f58533..3784dfe9b8c 100644
--- a/server/prisma/schema.prisma
+++ b/server/prisma/schema.prisma
@@ -394,3 +394,31 @@ model external_communication_connectors {
   createdAt     DateTime @default(now())
   lastUpdatedAt DateTime @default(now())
 }
+
+model scheduled_jobs {
+  id        Int                  @id @default(autoincrement())
+  name      String
+  prompt    String
+  tools     String? // JSON array of tool identifiers (null = use all enabled agent skills)
+  schedule  String // Cron expression
+  enabled   Boolean              @default(true)
+  lastRunAt DateTime?
+  nextRunAt DateTime?
+  createdAt DateTime             @default(now())
+  updatedAt DateTime             @default(now())
+  runs      scheduled_job_runs[]
+}
+
+model scheduled_job_runs {
+  id          Int             @id @default(autoincrement())
+  jobId       Int
+  status      String          @default("running") // running | completed | failed | timed_out
+  result      String? // JSON execution trace
+  error       String?
+  startedAt   DateTime        @default(now())
+  completedAt DateTime?
+  readAt      DateTime? // null = unread
+  job         scheduled_jobs  @relation(fields: [jobId], references: [id], onDelete: Cascade)
+
+  @@index([jobId])
+}
diff --git a/server/utils/BackgroundWorkers/index.js b/server/utils/BackgroundWorkers/index.js
index 85062b2b815..86ea0cbafe9 100644
--- a/server/utils/BackgroundWorkers/index.js
+++ b/server/utils/BackgroundWorkers/index.js
@@ -1,6 +1,8 @@
 const path = require("path");
 const Graceful = require("@ladjs/graceful");
 const Bree = require("@mintplex-labs/bree");
+const later = require("@breejs/later");
+const PQueue = require("p-queue").default;
 const setLogger = require("../logger");
 
 class BackgroundService {
@@ -8,6 +10,11 @@ class BackgroundService {
   static _instance = null;
   documentSyncEnabled = false;
   #root = path.resolve(__dirname, "../../jobs");
+  #scheduledJobTimers = new Map();
+  #scheduledJobQueue = new PQueue({
+    concurrency: Number(process.env.SCHEDULED_JOB_MAX_CONCURRENT) || 1,
+  });
+  #pendingJobIds = new Set();
 
   #alwaysRunJobs = [
     {
@@ -47,7 +54,18 @@ class BackgroundService {
 
   async boot() {
     const { DocumentSyncQueue } = require("../../models/documentSyncQueue");
+    const { ScheduledJobRun } = require("../../models/scheduledJobRun");
+
     this.documentSyncEnabled = await DocumentSyncQueue.enabled();
+
+    // Mark any orphaned scheduled job runs as failed (server crashed mid-execution)
+    const orphanedCount = await ScheduledJobRun.failOrphanedRuns();
+    if (orphanedCount > 0) {
+      this.#log(
+        `Marked ${orphanedCount} orphaned scheduled job run(s) as failed`
+      );
+    }
+
     const jobsToRun = this.jobs();
 
     this.#log("Starting...");
@@ -61,15 +79,24 @@ class BackgroundService {
     });
     this.graceful = new Graceful({ brees: [this.bree], logger: this.logger });
     this.graceful.listen();
+
     this.bree.start();
     this.#log(
       `Service started with ${jobsToRun.length} jobs`,
       jobsToRun.map((j) => j.name)
     );
+
+    await this.#bootScheduledJobs();
   }
 
   async stop() {
     this.#log("Stopping...");
+    for (const [id, timer] of this.#scheduledJobTimers) {
+      timer.clear();
+      this.#scheduledJobTimers.delete(id);
+    }
+    this.#scheduledJobQueue.clear();
+    this.#pendingJobIds.clear();
     if (!!this.graceful && !!this.bree) this.graceful.stopBree(this.bree, 0);
     this.bree = null;
     this.graceful = null;
@@ -140,6 +167,100 @@ class BackgroundService {
       });
     });
   }
+
+  // ---------------------------------------------------------------
+  // Scheduled Jobs — in-process cron timers + p-queue
+  //
+  // Bree tightly couples scheduling with worker spawning — when a
+  // Bree cron fires, it directly calls run() which immediately
+  // spawns a child process with no way to intercept it. We manage
+  // our own cron timers (via later.setInterval) to decouple
+  // scheduling from execution so we can route jobs through p-queue
+  // for concurrency control, dedup, and priority ordering before
+  // spawning workers via runJob().
+  // ---------------------------------------------------------------
+
+  /**
+   * Register cron timers for all enabled scheduled jobs on startup.
+   */
+  async #bootScheduledJobs() {
+    const { ScheduledJob } = require("../../models/scheduledJob");
+    const enabledJobs = await ScheduledJob.allEnabled();
+
+    for (const job of enabledJobs) {
+      await ScheduledJob.recomputeNextRunAt(job.id);
+      this.addScheduledJob(job);
+    }
+
+    if (enabledJobs.length > 0) {
+      this.#log(
+        `Registered ${enabledJobs.length} scheduled job(s) (max concurrent: ${this.#scheduledJobQueue.concurrency})`,
+        enabledJobs.map((j) => `${j.name} (${j.schedule})`)
+      );
+    }
+  }
+
+  /**
+   * Register an in-process cron timer for a scheduled job.
+   * When the cron fires, the jobId is enqueued for execution.
+   * @param {object} job - scheduled_jobs DB record
+   */
+  addScheduledJob(job) {
+    this.removeScheduledJob(job.id);
+    const sched = later.parse.cron(job.schedule);
+    const timer = later.setInterval(() => {
+      this.enqueueScheduledJob(job.id);
+    }, sched);
+    this.#scheduledJobTimers.set(job.id, timer);
+  }
+
+  /**
+   * Remove an in-process cron timer and dequeue a scheduled job.
+   * @param {number} jobId - scheduled_jobs.id
+   */
+  removeScheduledJob(jobId) {
+    const timer = this.#scheduledJobTimers.get(jobId);
+    if (timer) timer.clear();
+    this.#scheduledJobTimers.delete(jobId);
+    this.#pendingJobIds.delete(jobId);
+  }
+
+  /**
+   * Re-sync a scheduled job's cron timer after an update.
+   * Removes the old timer and re-adds if still enabled.
+   * @param {number} jobId - scheduled_jobs.id
+   */
+  async syncScheduledJob(jobId) {
+    const { ScheduledJob } = require("../../models/scheduledJob");
+    this.removeScheduledJob(jobId);
+    const job = await ScheduledJob.get({ id: Number(jobId) });
+    if (job && job.enabled) {
+      this.addScheduledJob(job);
+    }
+  }
+
+  /**
+   * Add a scheduled job to the execution queue.
+   * @param {number} jobId - scheduled_jobs.id
+   * @param {object} [opts]
+   * @param {boolean} [opts.priority=false] - If true, skip dedup and add to front of queue
+   */
+  enqueueScheduledJob(jobId, { priority = false } = {}) {
+    if (!priority && this.#pendingJobIds.has(jobId)) return;
+    this.#pendingJobIds.add(jobId);
+
+    this.#scheduledJobQueue
+      .add(
+        () =>
+          this.runJob("run-scheduled-job", { jobId }).catch((err) =>
+            this.#log(`Scheduled job ${jobId} failed: ${err.message}`)
+          ),
+        { priority: priority ? 1 : 0 }
+      )
+      .finally(() => {
+        this.#pendingJobIds.delete(jobId);
+      });
+  }
 }
 
 module.exports.BackgroundService = BackgroundService;
diff --git a/server/utils/PushNotifications/index.js b/server/utils/PushNotifications/index.js
index fad5c64a11a..0bf6b12265c 100644
--- a/server/utils/PushNotifications/index.js
+++ b/server/utils/PushNotifications/index.js
@@ -170,7 +170,7 @@ class PushNotifications {
    * @param {Object} options - The options for the notification.
    * @param {"primary"|number} [options.to] - The subscription to send the notification to. "all" sends to all subscriptions, "primary" sends to the primary user (single user mode only), a number sends subscription to specific user
    * @param {PushNotificationPayload} [options.payload] - The payload to send to the clients.
-   * @returns {void}
+   * @returns {Promise<void>}
    */
   sendNotification({ to = "primary", payload = {} } = {}) {
     if (this.#subscriptions.size === 0)
@@ -180,10 +180,16 @@ class PushNotifications {
         `.sendNotification() - Subscription for user ${to} not found`
       );
     this.#log(`.sendNotification() - Sending notification to user ${to}`);
-    this.pushService.sendNotification(
-      this.#subscriptions.get(to),
-      JSON.stringify(payload)
-    );
+    return this.pushService
+      .sendNotification(this.#subscriptions.get(to), JSON.stringify(payload))
+      .then((res) => {
+        this.#log(
+          `.sendNotification() - Delivered (status: ${res.statusCode})`
+        );
+      })
+      .catch((err) => {
+        this.#log(`.sendNotification() - Failed: ${err.message}`);
+      });
   }
 
   /**
diff --git a/server/utils/agents/aibitat/index.js b/server/utils/agents/aibitat/index.js
index 37a285b39a0..7562bcb2ab2 100644
--- a/server/utils/agents/aibitat/index.js
+++ b/server/utils/agents/aibitat/index.js
@@ -379,6 +379,18 @@ class AIbitat {
     return this;
   }
 
+  /**
+   * Triggered when a tool call completes and returns a result.
+   * Used by scheduled jobs to capture tool results for the execution trace.
+   *
+   * @param listener
+   * @returns
+   */
+  onToolCallResult(listener = () => null) {
+    this.emitter.on("toolCallResult", listener);
+    return this;
+  }
+
   /**
    * Register an error in the chat history.
    * This will trigger the `onError` event.
@@ -895,6 +907,11 @@ https://docs.anythingllm.com/agent/intelligent-tool-selection
 
       const result = await fn.handler(args);
       Telemetry.sendTelemetry("agent_tool_call", { tool: name }, null, true);
+      this.emitter.emit("toolCallResult", {
+        toolName: name,
+        arguments: args,
+        result,
+      });
 
       /**
        * If the tool call has direct output enabled, return the result directly to the chat
@@ -1059,6 +1076,11 @@ https://docs.anythingllm.com/agent/intelligent-tool-selection
 
       const result = await fn.handler(args);
       Telemetry.sendTelemetry("agent_tool_call", { tool: name }, null, true);
+      this.emitter.emit("toolCallResult", {
+        toolName: name,
+        arguments: args,
+        result,
+      });
 
       if (this.skipHandleExecution) {
         this.skipHandleExecution = false;
diff --git a/server/utils/agents/ephemeral.js b/server/utils/agents/ephemeral.js
index dd0626bf37b..b320533f690 100644
--- a/server/utils/agents/ephemeral.js
+++ b/server/utils/agents/ephemeral.js
@@ -437,6 +437,7 @@ class EphemeralAgentHandler extends AgentHandler {
     args = {
       handler: null,
       telegramChatId: null,
+      toolOverrides: null,
     }
   ) {
     this.aibitat = new AIbitat({
@@ -471,6 +472,13 @@ class EphemeralAgentHandler extends AgentHandler {
     // Load required agents (Default + custom)
     await this.#loadAgents();
 
+    // Override tools if specified (e.g., for scheduled jobs with per-job tool selection)
+    if (args.toolOverrides) {
+      this.#funcsToLoad = args.toolOverrides;
+      const agentDef = this.aibitat.agents.get("@agent");
+      if (agentDef) agentDef.functions = args.toolOverrides;
+    }
+
     // Attach all required plugins for functions to operate.
     await this.#attachPlugins(args);
   }